Saimon 1 BCD jako nástupce Logitronik 01

Mám doma starší stavebnici Logitronik 01, která už má po letech nespolehlivé kontakty. Zkusil jsem proto převést jednu z jeho základních úloh (invertor / NOT) na stavebnici Saimon 1 – školní verze (DEC/BCD) … z aukra

Saimon je mechanicky i elektricky velmi pěkně zpracovaný.Celá stavebnice působí moderně a nadčasově, je robustní a počítá i s chybami při zapojování – například má základní jištění proti přetížení. To z ní dělá vhodnou platformu nejen pro výuku, ale i pro opakované experimentování bez obav z poškození

K vyzkoušení jsem zvolil z Logitroniku 01 obvod č. 3 “Logický člen “NOT” jako invertor.” Obvod samotný byl jednoduchý, pro převod schématu jsem použil ChatGPT5.2 – občas otravného “robodruha”.

Při řešení zapojení mi také pomohla konzultace přímo s autorem stavebnice. Upozornil mě, že nad spínači jsou zdířky 110–115 na rezistory,které lze jumperem nastavit jako pull-up nebo pull-down, aby při rozepnutí spínače nebyl vstup „ve vzduchu“. Zároveň upřesnil, že k integrovaným obvodům je nutné přivést +5 V, zatímco zem je rozvedena přímo na plošném spoji.

Výsledný postup propojení na Saimon 1 BCD

Zapojení funguje stejně jako původní úloha na Logitroniku a lze stejným způsobem převádět i další logické obvody.

IO-2 NAPÁJENÍ-+5V,
+5V-116,
117-62-63,
117-93,
92-0V,
64-95,
94-0V

Chat GPT 5.2 umí porozumět schématům, dokonce zaznamenal i ručně dokreslené napájení a ground. Dokáže poměrně dobře vysvětlit základní koncepty v elektronice a doplnit tak mezery, které se např v původním Logitroniku nevysvětlují.

Poznámka k dalším možnostem

Při tomto převodu se ukázalo, že je praktické mít možnost se průběžně doptávat na detaily zapojení a interpretaci schémat. Nabízí se proto myšlenka jednoduchého Custom GPT zaměřeného přímo na stavebnici Saimon, které by pracovalo s ověřenými podklady (mapa zdířek, příklady zapojení) a sloužilo jako interaktivní náhrada stručného návodu.

Do podobného rámce by šlo zařadit i jednoduché ukázky principů učení, například základní analogový nebo diodový perceptron, kde je „učení“ realizováno změnou zapojení a zpětnou vazbou, nikoli softwarem.

návody ke stavebnici Saimon

Simulace obvodu

Na strance https://falstad.com/circuit/circuitjs.html zadejte File/Import from text a můžete si obvod také nasimulovat :

vložte tento text:

$ 1 0.000005 10.20027730826997 54 1 50 5e-11
s 304 64 304 144 0 1 false
r 304 144 304 272 0 3300
w 176 272 304 272 0
v 176 176 176 144 0 0 40 6 0 0 0.5
w 176 64 176 144 3
w 176 272 176 176 0
w 176 64 304 64 0
w 304 144 384 144 0
r 384 144 384 208 0 330
d 384 208 384 272 2 default-led
w 384 272 304 272 0
153 384 144 560 144 0 1 5 5
r 560 144 560 208 0 330
d 560 208 560 272 2 default-led
w 560 272 384 272 0

Letní imprese

Leave a reply

9. album od Maxmiliána Šumbery s názvem Letní imprese je nově k dispozici na Audiomack. Skladby Duo pro hoboj a klavír No.1 “Ametystové červánky” a Rozkvetlé louky se umístily ve zlátém pásmu soutěže XIII. Múzy I.Hurníka 2025. Navíc první z nich dostala také zvláštní cenu v kategorii instrumentální hudby.

Kotlin Bites Code

Leave a reply

Disclosure: AI-assisted content — consult with an organic-developer.

When building low-level libraries for the JVM — especially those that interact with JNI, rendering engines, or MethodHandles — the exact bytecode emitted matters. Recently I hit a limitation in Kotlin that reminded me why the JVM world still needs Java for certain things.

Where Kotlin Emits Different Bytecode than Java

Here are the main areas where Kotlin’s generated bytecode diverges from Java’s, and why that matters.

Area	Java	Kotlin	Takeaway
Signature-polymorphic calls	Emits correct signature for `MethodHandle.invokeExact`	Falls back to `(Object[])Object`, causing mismatches	Keep these calls in Java
Default parameters	No defaults → use overloads	Generates synthetic `$default` methods with bitmask	Avoid defaults in public APIs for Java clients
Companion objects / @JvmStatic	True `static` methods	Methods live in `$Companion` unless annotated	Use `@JvmStatic` or plain Java for static APIs
Internal visibility	Package-private supported	`internal` compiles to `public` + metadata	Don’t rely on `internal` for cross-language encapsulation
SAM interfaces	Any functional interface = lambda	Only `fun interface` supports SAM; lambdas may create synthetic classes	Define callbacks in Java for performance
Nullability	All references nullable	Annotations encode nullability, JVM doesn’t enforce	Explicit null checks needed in low-level code
Suspend functions / coroutines	N/A	Compiles to `(Arg, Continuation) → Object`	Keep coroutines in Kotlin wrappers, not core API

Other Kotlin Caveats for Low-Level Code

This wasn’t an isolated issue. Kotlin differs from Java in other ways that make it risky for core interop code:

Area	Java	Kotlin limitation
JNI declarations	`static native boolean render(int, int)`	Needs `@JvmStatic` in a companion object; generates synthetic names
JNI header generation	`javac -h` works directly	No header generation for Kotlin sources
Checked exceptions	Enforced at compile-time	Kotlin ignores them (all unchecked)
Raw types	Allowed (`List`)	Always requires generics (`List<*>`)
Wildcards	`? super`, `? extends` supported	Only `in` / `out`; cannot express everything
Default params	Not supported (overloads instead)	Compiles to synthetic `$default` methods
Static members	`static` keyword	Requires `@JvmStatic` in object/companion
Suspend functions	N/A	Compiled to `Continuation`-based state machines, awkward for Java callers

Why This Matters for Library Code

A low-level library often deals with:

JNI ↔ JVM bridges
OpenGL or native rendering loops
Performance-critical calls that must inline
Reflection and MethodHandles

All of these require predictable bytecode and signatures. Kotlin often inserts synthetic classes ($Companion, $DefaultImpls, $WhenMappings) or adapts signatures in ways Java clients (and JNI) do not expect.

Why Keeping the Library Core in Java Makes Sense

Benefit	Why It Matters
One language to maintain	Single codebase, easier contributor onboarding, faster builds
Interop for everyone	Java APIs work in all JVM languages; Kotlin clients lose nothing; Java clients stay safe from Kotlin-only features
JNI friendliness	Direct mapping of Java types to JNI (`int → jint`, `boolean → jboolean`); `javac -h` header generation works; avoids `$Companion`/`$DefaultImpls` surprises
Bytecode predictability	No synthetic baggage (`$Companion`, `$default`, `$WhenMappings`); avoids mismatched signatures; JIT optimizes exactly as written

Strategy: Java Core + Optional Kotlin API

The pattern I adopted (and which many frameworks use):

Core in Java
- Predictable bytecode
- JNI header generation
- Works with MethodHandle, VarHandle, Unsafe
- Safe for both Java and Kotlin clients
Optional Kotlin extensions (-ktx)
- Extension functions for ergonomics
- Coroutines (suspend wrappers)
- Null-safety
- DSLs for configuration

This is the same model Android Jetpack follows:
androidx.core in Java, androidx.core-ktx in Kotlin.

Takeaways

Point	Why
MethodHandle support	Java compiler emits exact signatures (`(int,int)boolean`), Kotlin falls back to `(Object[])Object`, causing runtime issues
Bytecode predictability	Java produces direct, predictable bytecode; Kotlin adds synthetic constructs and indirections
JNI compatibility	Java maps directly to JNI types and header generation; Kotlin introduces complications
Best practice	Keep the core in Java for stability and performance; add Kotlin wrappers for ergonomics (DSLs, coroutines, null-safety)

interesting link: https://www.okoone.com/spark/technology-innovation/why-kotlin-swift-and-ruby-are-dropping-off-the-radar/

References

Java SE Docs — MethodHandle and signature-polymorphic methods
https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandle.html
OpenJDK Wiki — Deconstructing MethodHandles
https://wiki.openjdk.org/display/HotSpot/Deconstructing%2BMethodHandles
Kotlin Docs — Functions and default arguments
https://kotlinlang.org/docs/functions.html
Medium — Kotlin Function Parameters and Default Values: Behind the Scenes
https://medium.com/@AlexanderObregon/kotlin-function-parameters-and-default-values-behind-the-scenes-6551fa515fa1
Kotlin Forum — Kotlin bytecode on default parameters
https://discuss.kotlinlang.org/t/kotlin-bytecode-on-default-parameters/6159
Kotlin Docs — Visibility modifiers (internal, etc.)
https://www.digitalocean.com/community/tutorials/kotlin-visibility-modifiers-public-protected-internal-private
YouTrack — KT-14416: Support of @PolymorphicSignature in Kotlin compiler
https://youtrack.jetbrains.com/issue/KT-14416
Baeldung — The @JvmStatic Annotation in Kotlin
https://www.baeldung.com/kotlin/jvmstatic-annotation
StackOverflow — How to call a static JNI function from Kotlin?
https://stackoverflow.com/questions/57117201/how-to-call-a-static-jni-function-from-kotlin
The golden age of Kotlin and its uncertain future https://shiftmag.dev/kotlin-vs-java-2392/

Rozhodnutí

Leave a reply

Po skoro 30 letech od ‘obyčejné’ klavírní verze je tu verze orchestrální. Překvapivě bohatá a rozšiřující původní námět. Zvláště střední a závěrečná, epicky znějící část, se mi velmi líbí. Orchestraci z původní skladby vytvořil a vhodně rozšířil Maxmilián Šumbera.

Decision_orchestral Download

Noční běžec

Leave a reply

Night runner, my favourite one released ! I love the uncommon accents forming a distinct rhythm, interleaving with a faster pulse — like a heartbeat echoing the rhythm of feet hitting the ground in that first minute.

Ground Truth

Leave a reply

Realita vs. iKatastr 3d. Vizuální srovnání pomocí fotek z terénu.

Analogové fotky vs iKatastr 3d

porovnání u prototypu zde

Olympus Pen-D

Leave a reply

This is another nice half-frame camera — the Olympus PEN-D. It has an uncoupled meter and a smart way of setting aperture and shutter speed together. Works great and produces nice photos. Compared to the Canon Demi EE28 , it’s a bit bulkier, mostly due to the faster Zuiko 1.9 lens.

It features a Copal leaf shutter, fully mechanical, so no batteries are needed. Focusing is manual via a distance scale. Zone focusing works well once you get a feel for it.

Shutter speeds range from 8s to 1/500s.

GIS Visions 2045

Leave a reply

I gave a presentation where GIS might evolve in 20 years from now as part of the GIS Ostrava 2025 conference on 5.3. 2025. it was great to see again colleagues ! get eye-contact with audience and not just virtual applause. Also nobody was showing physically thumbs-up or red heart (in that case I would call emergency), rather real spoken (I mean real sound wave based ) comments, real talk and smiles. That was the main topic of the talk – Spatial Interactive – with people, tech, discoveries. Step out of the ‘glass-illusion’ trap.

Spatial Interactive

Stanislav Sumbera, GIS Vision 2024, 5.3. 2025,GIS Ostrava 2025

What happens here is more important than what happens now.
Space is naturally interactive, enabling collaboration and sharing.
The computer is not behind a 2D glass screen but understands 3D space and interactions within it.
People learn through observation, collaboration, and play.
Community Computer
Projective Augmented Reality (Projective AR)
Bret Victor – Dynamicland

image sources:https://gislab.utk.edu/tag/ar-sandbox/ , Dyamicland.org, Lightform

HMD / Head-Mounted Displays – Apple Vision Pro
Spatial Computing
Control through advanced gestures
“Super persistence” of objects – digital objects remain anchored as if truly part of the physical world
Pseudo-haptic feedback – realism in rendering creates the illusion of tactile response
Currently at the “UNIX Workstation” stage of the 1980s – showcasing possibilities that will later become accessible to everyone.
Also bloged here

2. Web, Open Source, and Technology Accessibility

From Google Maps → OpenLayers → Leaflet → MapBoxGL → MapLibreGL → ?
Each step represents greater availability, democratization, and accessibility of mapping technology, pushing development forward.
How difficult was it to render an image in 1993? How difficult was it to share that image with others? And today?
What is difficult, expensive, yet possible today that will become commonplace in 20+ years?

3. Lifespan of Data vs. Lifespan of Technology

WMS – Simple for visualization
Vector tiles – More complex to render (OGC API Tiles, MapBox Tiles, MapLibre Tiles – MLT)
3D tiles – OGC 3D Tiles, evolving standards for spatial data
More aesthetics, smoothness, and artistic expression in maps
Real-time rendering techniques, such as Gaussian Splat, for next-generation visualization

from Book: Eneterpise SOA by Krafzig, Banke, Slama

4. Scanning Spaces and Objects

3D scanning is accessible to everyone
Spatial Video, Spatial Photo
3D scanning is as simple as taking a photo
Photorealistic scanning

5.Precise Geolocation ~2-10 cm

VPS (Visual Positioning System) – accuracy < 10 cm
5G geolocation
Affordable high-precision GNSS + RTK/PPP (< 10 cm)
Accessible VPS from panoramic images, Mapy.cz?

6. AI – Welcome to the Jungle

NPCs have become “thinking machines” (are we, on other side, turning into NPCs ourselves? aka Jumanji 2 )

Image from Jumanji 2,driver – Mason Pike ?

The Chinese Room paradox – an English speaker perfectly assembles answers in Chinese following instructions without understanding the Chinese language and symbols meaning.
AI cannot create true originality but excels at combining and compiling existing inputs – a “super plagiarist” or “super puzzle resolver” ?
Might replace a significant amount of human (intellectual + routine) labor – in GIS (georeferencing, recognition/classification), programming/syntax, and more
“Hard work for machines, thinking for people” (Tomáš Baťa) is evolving into “(Pre)thinking* for machines, creativity/ideas for people” (in Czech Language : pre-mýšlení)
AI model marketplace – grow (cultivate) your unique “thought twin” that integrates into an open AI network.
Developer Twin: Blog post

Wining is singularity, whereas losing conforms to a pattern.

Leave a reply

from page 16 of the great book uncommon sense, common nonsense. by Jules Goddard and Tony Eccles.

and p. 39: It is better to be first than it is to be better

2 quotes form czech book on Bata system :

Taylor, Fayol, Ford, and Baťa put an end to the old type of entrepreneur for good. They argued that profit does not depend on the numerically lowest wages, but on the highest and most efficient work performance, during which the worker works as if he were working for himself.

“Baťa’s factories produced and supplied most of the construction materials themselves. They had their own brickyards, carpentry, joinery, and locksmith workshops, which supplied standardized interior fittings to all homes, produced neon tubes, flooring, in short, almost everything they needed. And if there was something not included in their production program, they purchased it directly from manufacturers (excluding intermediaries).”

iKatastr novinky

Leave a reply

Novinky

24.7.’25 Podívejte se na zajimavé srovnání reality na fotce (kinofilm) s virtuálním pohledem do stejného místa v iKatastr 3d.

20.6.’25: Nová 3D verze, obsahuje reliéf terénu, výškové obrysy budov a využívá akceleraci grafické karty. Vyzkoušejte v testovacím provozu https://ikatastr.cz/3d

23.2.’25: zlepšeno rozlišení základních map pro ‘retina’ obrazovky. Oprava drobných chyb.

17.2.’25 aktualizována mapová komponenta Leaflet na poslední verzi 1.9.4.

27.1.’25: Přidána vrstva označující nemovitosti, které obsahují cenový údaj v katastru nemovitostí. Vyzkoušejte např zde. Ovšem sdělení konkrétní ceny je pouze na vyžádání na katastru. Viz ceník zde, položka 4021 a 4022.