nuriaion

Penpot is also implemented in Clojure/ClojureScript. ClojureScript is a Clojure Dialect which compiles down to JavaScript. So there is no Java involved on the frontend :)

It's physically pressed down to the pads on the motherboard with screws.

There is an issue if you want to create a small laptop with a long battery life as SODIMM will use more space and power as LPDDR. (The SODIMM module and connector are very bulky and have a bad electical layout. CRAMM will be somewhere between the two)

I think that would actually be more expensive as you still have the all the hard problems. Like how do you isolate the power electronics. You can use air which is cheap but needs a lot of space. (i learned that you need 1mm per 1kV) You need a lot of space which has to be very secure. etc

Additionally you need to control 5000 converters without getting oscillations etc. (probably over glas) Also they will probably need a lot more space.

Good HiDPI scaling on my external Monitor is one of the reasons i switched back to os x. For me that works very good independent of the monitor manufacturer.

We made it part of our ci to test if all files are formated with the formater and i bound the formater to the save operation.

So i can just write, save the file and everything is nice :)

That's a nice way to get gdb!

In our case it would probably not have helped. We had a fixed old mcu board where the functionality grow over the years. We were fighting over bytes...

Some years ago i worked on a part of a specialized steering system for a car. This was done with certified everything (Certified Compiler, Processor, a lot of paper work etc.)

This was a 16-Bit processor and the C-compiler had a "funny" bug. If you had a struct with 3 8Bit Values in a row and a 16Bit Value afterwards it would overlap the 8Bit Value with the 16Bit value:

  struct {
    int8 a;
    int8 b;
    int8 c;
    int16 d;
  }

At which company is the largest Haskell team in the world?

Also i would assume that the non-Tesla offerings will be cheaper. What i saw about the automobile industry ist that they are very good in building factories/supply chain's where they can produce as cheap as possible. The setup of such a supply chain takes years but when it's there i assume that the prices will be lower than Tesla's. (Also so far i know Tesla need's still a relativ big amout of work hours per car, 60h compare to 30h industry standard)

The space in an instruction is very limited. (If the representation of an instruction needs more bits you need more bandwidth, more cache space etc.) So it can be beneficial to only address 8 registers but then have a detection for spilling of spilling to RAM etc. (It can even be beneficial to specify only 2 registers (a = a + b instead of a = b + c) and replace a copy of registers with a rename.

Depending on your architecture and compiler it could be that everything is 128 bit aligned, so you would had "empty holes" in your memory layout. (For example some dsp's)

Basically you have no guarantee where the pointer q is pointing to. Some compiler/static code analyzer will yell at you with this code.

Still very early but a good try: https://isomorf.io/

What also helped me understand CT a little bit better was the book "Haskell Programming from first Principles" (http://haskellbook.com/)

This also needs a lot of time and effort to comprehend!

I can recomend the video series of Bartosz Milewski (https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbm...) I'm at the 4th video and it's the first time that i start to become an understanding of the howl thing.

But expect it to take some time. (10 Videos, most are around 1h, i needed to pause several times and think or try something out)

We (small startup/company in Switzerland) are mostly exporting our product. Today we changed from making a profit to making a loss with each system we sell...

When i was in Zimbabwe (5 Years ago) the biggest prepaid refill card you could buy was around 1$. (That was enough for a several minutes call back to Europe.) If you wanted more you had to buy several refill cards.

Maybe these Connectors are for daughterboards with Centaur Chips + RAM. (A Power8 can connect to 8 Centaur Chips where the RAM is connected)

As far as i understood the slides the stack overflow part is only one critical problem.

The v850 has 1...256kBytes of RAM. Let's assume 256kBytes of RAM. Then lets assume they have a Stack of 16kByte. => There are only 983 Bytes of free stack. Then a function call with 5 Int parameters and 10 Int variables needs around 64Bytes. => Only 16 recursive calls are needed to have a stack overflow.

Further because the critical data structure in the os are not secured the os will have no idea that something is wrong.

(In several projects we had to have our critical data 2 times in RAM, once normal and once inverted. In a critical project we even had to do all computations two times, once with the normal data and once with the inverse data. This way you will also find some bit flipps of the ALU, RAM etc.)

edit: In the slides i found that the stacksize is 4kByte => only 245Bytes are free! So you can't make many recursive calls!

At work (Switzerland) we use pcb-pool.com. I think it's cheaper than Fritzing and you have more options. (Multilayer etc.)

During my Education to Electrical Technician ("Lehre") in Switzerland we had a lot of exercises to learn debugging. One was that we got a blackbox with some pins and some maximum ratings and we had to find out what circuit is inside. Or we got a Circuit with a defined function and had to find out if it works as expected or not. And so on. This was also a big part of our exams.

Then on the University the education shifted to a very theoretical approach.

Sorry didn't found the old discussion in my (extremely short) search.

More info about Akka Persistence (ex eventsourced): https://github.com/eligosource/eventsourced

Java can also become very complex because of it's simplicity. Sometimes it can be hard to read java code just because there is much more of it.

Hi

I really like the idea of circuits.io. Here some things i noticed during a short test. (Probably you already know all these things)

Some kind of an "Push Obstacle" Layout mode would be nice. (Move the obstacles when you try to lay down an wire) Or at least a "Walk around Obstacle".

Have an adjustable keymapping. (i prefere to have zoom on "A" + "D", pan on "W", start routing on "S" etc. )

I wasn't able to change the layer (| is Alt+7 for me which your app doesn't seem to recognize)

Add more layer and Polygons/Planes. (Our standart pcb has 4 Layers. GND, VCC, 2 times routing)

The device search is just lame.

It would be nice to be able to edit a project as a team. (Have a history of changes and who made this changes, add a possible to review the changes, etc.)

You have to be a little careful to make sure that the conditions of the study are matching your conditions.

As an example the TDD study you mentioned compared the defect rates of a new software developed once with TDD and once with Code Review. At work we do TDD mostly to help us developing (faster feedback if the code does what i want, running it on the target needs 10+min), to have an example how the code should be used and to now that a refactoring broke something unrelated.

If it helps us with a refactoring or reduces the defect reduction rate that is a nice benefit but not the main reason why we use TDD.

So it depends on what you do if a study is applicable or not.

What i wanted to say is that 20kloc is a lot even for C. (Specially for "only" generating the parameters. Diggum sad that it was more like 2kloc which sounds resonable.

20kloc of C sounds like a lot and 4 days like too little. As a comparsion at work we developed a drive-by-wire system for handicaped car driver. This Software has around 22kloc of mostly C and some configuration/make files.

If both Java and Scala is new to you i would suggest to start with Scala and learn to read Java by the way.

I came from a background of a lot of Embedded C and some Ruby. For me Java had more a feeling like C. Very clumsy and needs a big amount of code to describe something.