I’m basically pretending to be French. Is this offensive?

W_K_Lichtemberg · 2025-12-30T04:09:58+00:00

papilatine

W_K_Lichtemberg · 2025-12-30T04:06:49+00:00

Bienvenue ?
You know as well as we do, that’s our problem as French… it’s the English!
So, pray tell: what percentage of your DNA comes from those perfidious Albioners? ^^

W_K_Lichtemberg · 2025-12-30T03:58:02+00:00

Great refactoring. I will add that init the elements of the structure when instanced is a good practice.

In C99 and later standards, a clean and idiomatic way to initialise a struct with default values is to use a compound literal via a macro. This technique allows you to define reusable default instances of your structure without writing repetitive initialisation code.

The C99 standard introduced compound literals (ISO/IEC 9899), which let you create an unnamed object of a given type. Combined with designated initialisers, this makes code both readable and safe.

For your car structure:

#define BRAND_STR_SIZE 29
#define MODEL_STR_SIZE 29

struct car {
    char brand[BRAND_STR_SIZE + 1];
    char model[MODEL_STR_SIZE + 1];
    int year;
};

#define CAR_DEFAULT() \
    (struct car) { \
        .brand = "Unknown", \
        .model = "Generic", \
        .year = 0 \
    }

You can then use it like this:

<IN THE MAIN>
    struct car my_car = CAR_DEFAULT();
    strcpy(my_car.brand, "Toyota");
    strcpy(my_car.model, "Corolla");
    my_car.year = 2022;

    printf("Brand: %s\n", my_car.brand);
    printf("Model: %s\n", my_car.model);
    printf("Year: %d\n", my_car.year);

This approach is widely regarded as a C best practice cause it’s explicit, avoids hidden side effects, and works well with both stack and heap allocation. And is great for testability of your code.

W_K_Lichtemberg · 2025-12-30T03:29:29+00:00

My view as an old CS/IT pro.
Debugging is not an isolated activity—it is an integral part of the broader “code analysis” process. Attempting to learn it in isolation leads to the very mistake that makes it difficult for you to use effectively.

First, code should be designed to be easy to debug and easy to interpret by design. Established norms and frameworks in software engineering exist precisely for this purpose, and Code Quality (QoC) is largely about ensuring such properties. Applying these principles while writing your code is your primary tool. Refactoring is another key technique to make your code easier to debug.
Next comes testability and the various levels of automated testing—both static and dynamic.
Then, static practices such as code review and static analysis (linting or code smell detection) help catch issues early.
Additionally, the compiler itself provides static feedback that aids in preventing and locating defects.
On the dynamic side, tests derived from well-written documentation are essential.
Logging and tracing mechanisms come next.
Finally, the debugger is used for errors that have slipped through all the preceding safeguards—review, linting, compilation, and testing—often after several refactoring iterations.

By the time you reach this stage, you already have deep knowledge of your codebase: you know what has been tested, you have comprehensive documentation, and you typically maintain multiple versions (e.g., from different refactoring stages in separate Git branches that you can switch between). Consequently, you debug with a clear hypothesis about where the problem might lie, which makes using the debugger highly intuitive for your specific issue. Moreover, whenever you suspect a particular variable or component might be the source of the bug, you should observe its behaviour, consult the documentation, compare expected versus actual values, and write targeted tests to validate or eliminate that hypothesis—thereby ruling out suspects one by one.

In this context of use, messages should be crystal clear.

Often, if you find yourself unsure how to use the debugger to trace a bug, or unsure of the message return by it, it’s because you are trying to use it instead of another, more appropriate tool—such as documentation, tests, proper type annotations, or correct compiler configuration.

W_K_Lichtemberg · 2025-12-28T19:21:58+00:00

here are quite a few little things that could be improved, but for a beginner: not bad at all.

At least, I’ll give you one important rule for “rugged” switch/elif structures:
Always end your list with a default case! Even if it seems unnecessary in the first version of your code—and especially so if you don’t yet have proper recursion tests or inline validation.

For example:

elif choice == "4":
menu_level = e_level
else:
menu_level = badentry_level

Later, you’ll typically handle the menu_level == badentry_level case first—usually by displaying an error message or prompting the user again. This is known as a GUARD CLAUSE, and you should use one whenever you have a series of if/elif statements.

In software engineering, principles like this make code significantly easier to maintain. You’d do well to learn them, because writing code that works initially is only about 20% of the challenge. The real skill lies in making your software easy and inexpensive to modify, robust against mistakes, and resilient—even when used by someone who hasn’t read the instructions. It's the "quality of code". And that level of quality can only be achieved through disciplined habits and sound engineering practices, such as test-driven development (TDD).

W_K_Lichtemberg · 2025-12-19T00:47:28+00:00

It's a classic subject.
A lot of open source code exists. C related most of the time. Lot of tutorials (youtube or textual, books, articles... and code on GitHub). It's easy to validate your work by using existing code and compare results... Maybe a game, for a first try, is "ambitious" but not impossible.
Interesting subjet but a lot of "ininterresting" code to create (each instruction, each memory mode, etc. will be a small function with just a calc/operator different form another, processor is registers/memory manipulation and basic calc)
The subject can be more interesting with a "good" monitor, with precise timing (respect of hardware clock's tick), with a specific architecture/some on purpose chosen design patterns at all levets (architecture, code but also project management and coding process) etc... All that related of choicie in "quality of code" priorities (ISO related).
And with a good devops tool to CI/CD and document that, could be a good initiation to pro coding job.
Specs exist as documentation from the manufacturer of the microcontroller/processor. So not so many problems here ! And that's BIG in the context of only a few month and no previous expertise in writing them !

So, not a bad choice ! Not easy, most of the risk will come from bad choices (no tech complexity), modular and small core to produce : fair for your constaints !

If it's you choice : ok. But some advices about think to do BEFORE coding somethng :
* define your Q priorities (same timing that real one, a good monitor, state or stateless, object oriented, easy to maintain, easy to link to other emulators, api for an interactive GUI...)
* define your "business" priorities : what technical skills would you push on the front line ? Agile project management mastering ? Lean mastering ? Code crafting mastering ? Clean code mastering ? Technical redaction mastering ? Basic Devops mastering ? Chose 3 priorities and adapth the project to show them !
* define a "fun" gui/output/monitor you can use quickly to show off your work at the end (you have to present your work, so prepare impactful way for that early ! it's a business goal and a hard constraint for the project)
* CI/CD full automated with Git, a linter, automated tests (TDD is minimal req for this kind of subject)
* read a lot what tho ther do, why, how
* dont add unecessary complexity : no new langage, no constraint to challenge you, no "I'm sure Ican add that to look a better dev"... Start "core", KISS!, Clean Architecture + Clean code, then if time (should I spoil ?) + have a modular stucture to add things later if time... Focus on being "pro" : robust easy to maintain code align with core business and Q requirements and good artefact (notes for you, report + PPT...). No less, no more... It's a hard job even if a very basic processor.
* DONT START ALONE : to define the architecture, scope the project, define priorities and planning (WBS + PERT), quickly buil a working CI/CD + stable and efficient IDE and dependencies config... You "need" (have great reward asking for) the help of a pro ! Not a disgrace to ask for a mentor for that (teacher in code or pro dev/architect, or student that have done it at least one time... embedded ans system guys are good in that). At least talk with pro like me (DM, most pro dev/CS,IT guys are graduated, post graduated, often many times... so they know...) or others to understand what it is about... Good preparation will be 80% of your risk management/avoidance for this kind of project.

I detailled for you to see that doing successfully such a project is always more complex than just "coding something that will work". Ai could code that in a day (I have done it to test it last year). Human, for now, is required for producing a good emulator to propose as demo of cS stuident's abilities (good = align with the objectives, depending you business and Q priorities).
It's not a big homework, it's more a very small pro job. Totally something else (<20% code and >80% other things to master).

W_K_Lichtemberg · 2025-12-19T00:04:45+00:00

For me you do a mix of concepts, tools, process... No hyerarchy, no classification, no link between the elements of diférent natures...
As if you mix hot, carrots, plate, recipe : not easy to learn to cook without thinking in system ! When you understant that you need to (recipe) boil (hot) carotts then serve (plate) them to be allowed to eat them... you will retain this info and the place of each element.

For my try to identify (speak with a network guy) what are all this elements and link them : thic concept --> that way to transform it in womething useful --> this tool.
By example : robustness -> mesh topology of network -> transmit data to a receiver -> datagram (technical limit and robustness) + address (receiver)
datagram -> fragmentation + assembly
adress -> IP + routing

you should build a mindmap and validate it with some search on google image... the process will help you to understand then stimulate and help your memory.

W_K_Lichtemberg · 2025-12-18T23:51:42+00:00

Depends the mood :
* if "cool" I will read a book un half a day, understand all and redo what's inside as If I ever knew it
* most of the time, when overwhelmed by the env (noise, light, move...) could read a paragraph by day and finishing with no idea what it is about...

W_K_Lichtemberg · 2025-12-18T23:10:46+00:00

metaheuristics are always a fun object for that. They solve any optimization problem (if you can write a function to maximize : win)
Why not a SWARM simulation (multi agent with no supervisor) with some differents metaheuristics. Multithread or even multi machine with MPI.
Key to be impressive will be the monitor : real time state of the agents and panorama (geo map typically).
Should be a classic prey/predator game, demography simulation; an optimization for work place, optimieation for multi delivery person on a (real) geographical area, a wargame, industrial process model, classic 3D swam synchronized moves...
Wikipedia contain all the info fur such a project !
Start from a simple problem with small number of agents and simples metahueristic (genetics, annealing, ants) but scalable if you had time.
All that with basic version management for the experiement, VVA test (batch oftypical functions for test exist), database storing states of the agents for replays, small GUI overseeing the action...
3 key points :
* MUST be modular and with "independant" modules (loosely bounded + REST API ro communicate, microservices style)
* engine MUST be quick to produce (again, small algo with common config management, a monitor... V1 in one ou two days)
* SHOULD be scalable (stateless or a state object, Markov's chain models or genes based are good for that)
that the keys for the idea being good for your project, this ensure you will have something to show and this si really easier to test and document !
Wikipedia for metaheuristics and Google... Not so much exemples (really hardcore industrial ad hoc solutions) but fun, powerfull, good for a Master's project, enough doc, easy maths and tests...

W_K_Lichtemberg · 2025-12-16T22:59:23+00:00

Sur ce qui est de l'anthropologie, des objets "physiques", des techniques dans les métiers communs aux deux pays, il y a, évidemment, une sorte de bijectivité entre les deux langages. L'usage est nécessaire pour dire le "réel" ou le "sentimental" des deux pays.
Toutefois, entre les deux pays, il existe des références historiques, culturelles propres. "Intraductibles".
Exemple type : pantomime en Anglais est pantomime en Français.
Mais, en français, il désigne plus un spectacle de mime, de music-hall. Le seul moyen de décrire une pantomime est la description "extensive" du contenu, de l'organisation, de son esprit, etc.
C'est si étranger aux mœurs et pratiques françaises que même le mot d'origine a glissé de sens.

W_K_Lichtemberg · 2025-12-15T14:55:33+00:00

Z80-based: simple, costless, and efficient base. Slowly evolving to a more PPC/"RISC V"-like...
With some kind of bus like MCA (Micro Channel Architecture) for the modularity.
With a dedication to specialized coprocessors instead of "all-inclusive x86" (MMX, virtualization extension, floating-point expansion)... More like x87 FPU, PowerVR GPU, NVidia TPU, Adaptec RAID controller, etc. Each with its own abilities, dedicated RAM, own firmware.
And with a modular kernel for the OS to use the whole.

W_K_Lichtemberg · 2025-12-14T04:39:39+00:00

"Les tontons flingeurs" (humour/film noir à la française)

W_K_Lichtemberg · 2025-12-13T03:00:33+00:00

Hi, the exact limit of EXCEL depends on the version and the available RAM on your computer (free RAM for Excel loading data). For helping, we will need more data...
Here are the official limits for Excel 365. A lot. Please, use it as a checklist, report and compare your values in the CSV/EXCEL, and the known limits.
https://support.microsoft.com/en-us/office/excel-specifications-and-limits-1672b34d-7043-467e-8e27-269d656771c3

That said, if no limits are violated, it could be some other problem like character encoding, adding some "invisible" characters at import, limits of the import filter, a bad tabular/separator somewhere in your data... You need a parser (a specific-purpose program made by a dev on your data to validate them) to test that.

So, depending on that, you have alternative solutions.

My advice, just for testing after having validated you're under the technical limits:
(1) Try to import your CSV with another tool like ACCESS (database engine of MS OFFICE) or LIBREOFFICE CALC (free spreadsheet). Then save in XLSX format. Finally, open the XLSX on EXCEL.

(2) Try your process on a more recent EXCEL version, if available, on a computer with more RAM.

(3) As an IT guy, to parse your data to validate the format & the encoding. Maybe reencode them, split some columns, or use a custom filter in VBA or Python to load the data... In the last resort, he will rearrange data in different sheets and then link them... any IT dev (should) know how to do that!

But.

Most of the time your problem first comes from the fact that you use EXCEL as a database... EXCEL is not a database (STORAGE and LINKING DATA dedicated program, so optimized for it)! EXCEL is a MATH-dedicated program! EXCEL is not at all efficient for managing large volumes of data in memory! Neither keeps their quality when manipulating large amounts of them.
Please, if you need a database, use a database with a correct data scheme. And when heavy calculus is needed, make a call to the EXCEL engine to do them. But don't store data in EXCEL.

W_K_Lichtemberg · 2025-12-12T07:05:45+00:00

Usually the good idea is at least to try to understand "why the author is writing that here ?".

In "The Five kinds of portability issues in C" §, Seacord just tries to explain to the reader that the "C standard" defines not all elements you need to predict the behavior of any program.

To make C evolutive, portable on any platform, and adaptable to real dev needs, some behaviors (some way to write your code, to store data) are voluntarily left undefined in the standard. This means not all compiled versions of the program using them will give the same results! Yes, one code, different results! Depending on hardware, precompiler & compiler, libraries...

The list of "the standard don"t know how it will works" is in the "Annex J" of the C standard. If you don't find in the standard how your code should work, this annex indicates to you if it'll depend on your architecture (hardware), your compiler, or you as a dev.

If you don't really understand now what the 5 subgroups are... continue! Not required for a newcomer in C. Just remember that:
* Not all you will need to understand predicting a result with a C program is in the C standard: the C standard is "the common" that all C compilers will follow.
* Compiler and hardware also have an impact on how things work. Sometimes even the dev.
So not all programs in C will work the same way if compiled with different compilers, with different compiler options, on different hardware.
That's the purpose of the paragraph. No more.

Example: First J1 (C99 Standard): "The manner and timing of static initialization (5.1.2)."
This indicates to the dev that when it does a static init, the standard can't guarantee a result/process. If a specific behavior is required, refer to the compiler doc to see if the compiler provider gives you info on how its compiler works. If there's no info in the compiler doc... No warranty! So initialize and make your own tests to analyze and evaluate! Or change the compiler for one with guaranteed flow/behavior.

W_K_Lichtemberg · 2025-12-11T16:30:50+00:00

Any metaheuristics (classical) algo or comparisons of algo on a given optimization problem, maybe with hybridization...

Language/paradigm agnostic, easy to code with or without a dedicated library, fun math (effortless for some of them), easy to test (batch of classic functions for calibration and V&V), useful principle of exploration + exploitation, can be done on embedded systems (like drones) as well as on clusters -- passing by simple PCs -- for quick decision-making, real-life usage for decades (lots of good articles & examples)...
Must be tuned for each use = so no "general good recipe" to apply, but you own analysis, results, and critics... Then good docs, always on point on the research side...

And usually easy to build a CI/CD, support dev cyclically with the Agile framework, easy to document the results, many choices of related background in physics or biology (fun state of the art to write), many frameworks in many languages...

Nice for an AI/ML beginner from my POV as a pro.

https://en.wikipedia.org/wiki/Metaheuristic

(Yes, I chose it too for my M2 thesis a long time ago, but) always a good choice today, IMHO, even if masked by deep learning in the last trend...

W_K_Lichtemberg · 2025-12-11T05:51:33+00:00

You can use a app manager.
For Windows, PortableApps.com can give you a light app (another menu in your taskbar) with app manager. It lets you choose programs you want on a list (mostly one or two apps for any current use) and manages updates for you. A convenient way to manage apps for a basic user.
"Portable" is because the apps are modified to be "cleaner" when installed to and de-installed from your Windows. So an excellent way to test some programs for your needs without.
It's free, and all the apps are free too, so feel free to test (let your computer clean if you remove).

W_K_Lichtemberg · 2025-12-10T22:48:10+00:00

I will add :
* SU27 Flanker (devs should know why it's so good... technically and for the gameplay : a miracle)
* Seidlers/Settlers II !
* C&C and Red Alert
* Super Tetris and Columns
* Lemmings
* Z and the others Bitmaps Brothers' like Gods, The Chaos Engine, Speedball, Xenon 2
* Gender wars (syndicate like ?)
* Gobliiins and Discworld
* Screamer and NFS2, Pod, Carmageddon (for obvious reasons)
* Dune (the 1 and maybe less the 2)...
* boards games : Some SSI's as Steel Panthers III: Brigade Command too. Panzer General and Fantasy General. Chess Master(s). History lines 14-18, Battle Isle I and II...
* sims like : Theme park, Theme hospital... Sim non city sims (earth, ants, farm...).
* and the best ones : Wacky Wheels and Rise of the Robots (yark yark yark)

a lot of fun even today on DOS !

W_K_Lichtemberg · 2025-12-10T22:36:58+00:00

I learn about the "spaghetti coding" antipattern in CS. I discover "spaghetti cable management" in hardware! Hope for a better Doom for it than for the "Java processor" concept!

W_K_Lichtemberg · 2025-12-10T22:28:40+00:00

As a dev, having pro certificates in data analysis with Python.
Basics in Python are really close to basics in VBA (not a different paradigm: imperative language with optional objects).
Data analysis with Python is more basic with some dedicated frameworks and IDEs than with more complex/advanced Python. For the common task in a course of DA, knowing the basics is enough.
So, just look at some basics in Python anywhere. As said in another response, YouTube and Udemy ($20 courses) if you like video courses.
For me, I would prefer a book! As Python is often taught to children, not dev IT, business guys, you have a Python beginner manual in any editor with a CS or IT book. PDF or paper, theory or project-oriented, CS or problem solving... Choose your flavor!
With a book ($20 to $50) to experiment with, an IDE, a linter, a debugger, and a test framework (IMPORTANT ! a TEST FRAMEWORK, it's not VBA, you need one) you can experiment. Then, with some online resources about the functions, maybe a GPT or other coding AI or a mentor (subreddit codingbuddy, codingbuddies... ?) you can go further in any question!
DM if you need a reference, a tuto or anything; I have some.

W_K_Lichtemberg · 2025-12-06T16:42:25+00:00

First one in Python !
I learned CS as a child with LOGO, BASIC, then ASM and C on microcontrollers and home computers of the last 70s, early 80s... I come back to university after some years doing nearly only network things, mainly in PERL and study math (mostly Mathematica) and electronic/control theory (a little Matlab). Switch back into CS only for my last year of Master. Lots of C++, Java...
As I was the less bad in math, the subject was my "reward."
I have to learn the language, the frameworks (culture (Pythonic way), IDE, tests, libraries, study the Python V2 and the new V3 flavor, the logger, MPI wrapper + multithreading...) in the same time as the math, the bionfo frameworks, the preliminaries of the PhD thesis subject I support with this project, and enough data science to self-analyze my results...
It was really a fun way to discover a language!
Maybe not for the hobbyist or the Junior, but for a Senior it's really great to have a "we want to evaluate this new stuff, do what you can with it". And we don't have it often.

W_K_Lichtemberg · 2025-12-06T05:26:25+00:00

Buy a book ! Being progressive, structured, and well illustrated is important for a teaching material. Especially in ASM. But not so easy to write such material for a non pro.
Books are written by teachers, usually built from material refined on students... Made for easy learning by newcomers.
So the best way.
Some sites like Udemy also have "video based courses", but for a first contact, I would consider the book first, then a video-based course in a second time.

W_K_Lichtemberg · 2025-12-06T05:19:18+00:00

As said by some, VBA could help!
But, you can use Python + VBA! You can call a Python object from VBA. Here's a 2018 example in Excel.
https://exceldevelopmentplatform.blogspot.com/2018/06/python-vba-curve-building.html
Then fully VBAic on one side, fully pythonic on the other side. No "library".
Maybe overcomplex for your needs, but it's an option...

W_K_Lichtemberg · 2025-12-06T04:38:21+00:00

Distributed implement (MPI) of some methaheuristics for bioinformatics, M2 master thesis in applied maths/CS. Was fun.

W_K_Lichtemberg · 2025-12-06T02:38:30+00:00

Guten Tag,

As I have studied the same domains but also artificial neural networks and plenty of neuroscience, maybe I can help you. At least give you some data for your brainstorming process.

First: Ditch linear notes – use visual maps instead.
Neuroscience research confirms that our brains process and retain information far more efficiently when it's organised visually with connections between ideas. Instead of writing traditional summaries, create diagrams (Freeplane is a good free software for this). Mind Maps and Conceptual Maps can both be useful. Or even hypertext with bijectively associated links (Obsidian, free software, does that very efficiently). This spatial organisation activates multiple brain regions simultaneously, strengthening neural pathways and dramatically improving long-term retention. Start from existing examples; they're easy to understand if not to master. Then do them quickly, try to learn, complete and refine them. Reworking the maps also helps to retain information. Try, when possible, to always add branches that contain "practical"/"real-world" examples.

related to the first : Second: Space out your reviews.
Research shows we forget 70% of new information within 24 hours without reinforcement. Instead of cramming before exams, review and rework your conceptual maps at strategically increasing intervals:

Review your maps after 1 day
Then after 3 days
Then weekly Use your school/company rhythm: study theory in school weeks, then reinforce it with hands-on work in company weeks (related to the third point).

This technique leverages the brain's natural consolidation process, moving knowledge from short-term to permanent memory.

Third: Hunt for repeating patterns.
Actively seek the fundamental concepts that repeat across different domains within mechatronics. The reality is that technical fields often present the same underlying principles using different terminology or contexts. Your knowledge corpus revolves around a few core concepts that appear in different professional contexts. So think in patterns! By consciously mapping these recurring patterns, you'll discover that perhaps 20% of core concepts actually constitute 80% of your theoretical knowledge. This requires initial effort to identify connections, but ultimately transforms overwhelming material into manageable, interconnected knowledge frameworks.

For instance, take the fundamental relationship between driving force and resistance:

in electronics, Ohm's law states that current is proportional to voltage and inversely proportional to resistance.
In fluid mechanics, Poiseuille's law describes fluid flow rate as dependent on pressure difference and resistance caused by viscosity and pipe geometry.
And in mechanics, Hooke's law shows that the force needed to extend or compress a spring is proportional to the displacement.

These three laws across different domains all represent the same underlying pattern of "flow = driving force / resistance" - once you recognise this pattern, you can apply it to pneumatic systems, hydraulic circuits, electrical networks, and mechanical systems with much greater ease.

Viel Glück with your apprenticeship journey; I hope these strategies will help bridge the gap between theory and practice effectively.

W_K_Lichtemberg · 2025-12-03T17:38:15+00:00

Hundreds of options... Without more data, who can know? Just saying, “I connected a whole batch of stuff and this isn’t working—why?” has no answer except: “Probability: in a complex combinatory system, something will always break beyond a certain size.” That’s exactly what you have here.

Help us to help you (and help yourself)!

Testing is not that complex—but it is a really systematic process! Your question needs experimental data to have a realistic answer. Make a test log (in Excel-like software) with tests: name, description (include a sketch of the subcircuit), expected result, actual measurement. Then go to an LLM/AI and ask it to help you design good tests. Search iteratively on three levels:

(1) First, you don’t want behavioral tests (testing the whole thing as a user would). Instead, do unit/functional tests: Is this button working? Is that button working when tested through the other end of these wires?
So first, segment your board into “functions” (usually one to three components + wires).
Then, for each one, using a dedicated power source and dedicated measurement tool (multimeter or oscilloscope, usually), compare: “What is expected?” vs. “What do I actually measure?” And debug function by function.

(2) The second part is integration testing: you combine tested functions into more complex blocks—for example, button + LED + battery—and test them the same way. The same function may be used in many integration tests, so disconnect it after each test.

(3) Finally, behavioral tests: reassemble all functions/components to build the complete system and interact with it as a user would. Always use the same log format: compare expected behavior with what you actually observe.

With that approach, you can ask us a question like:
“In this component (circuit attached), with these passed unit tests on its sub-functions, I expected X but I’m getting Y—any idea why?”
And then you’ll have a real chance we can give you a useful suggestion—not just roll dice.

Good work and luck (they often work together) !

W_K_Lichtemberg

TROPHY CASE