henrikeh

The Ada programming language. We (at my work) have been considering it for a new project and mostly everything has been a pleasant surprise. It is not a language that makes you feel “clever” or “powerful”, but everything has its purpose and place.

Except for Tasks; the fact that such a bare-bones language has first-class support for concurrent execution makes it clear how ahead of its time it was.

Another technology was optics and specifically fiber optics. I went into the field with knowledge of microwave engineering and I am surprised by how similar it is. I thought it would be a completely foreign, but the high level concepts are actually relatable to microwave tech.

Curious: which language?

I believe it is so, at least here in Denmark where any new hole in the ground is potentially an uncovered settlement.

I recently had a chance to visit the dig at “Ringborgen” near Køge. They only dug as little as possible and with a very directed effort: answering questions such as “what is the age”, “did they have fireplaces”, “are the signs of buildings” etc. once they got the “data” they cover the site again and preserve until new questions need answers (which potentially involves new methods).

In this case they had learned that the found settlement in Køge was build and deserted in a quite short time span. This raised a question with regards to other possible sites in Denmark: are there other sites with this pattern of it being deserted quickly? So old sites might now be redug.

Sources: had an excellent tour at the site in Køge; a friend who works as archaeologist.

FYI: I believe you have to use the flag -gnatn or -gnatN to inline packages with GNAT.

Optimizing your project: https://www.pegasoft.ca/resources/boblap/7.html

GNAT: Alphabetical list of all switches: https://gcc.gnu.org/onlinedocs/gcc-8.2.0/gnat_ugn/Alphabetic...

Wolfram Language / Mathematica has “string patterns” which extend the built in pattern language to character-based matching. Within the context of Mathematica is a quite readable and familiar syntax.

https://reference.wolfram.com/language/guide/StringPatterns....

Curiosity was too heavy for the airbag-style landing: https://en.m.wikipedia.org/wiki/Mars_Science_Laboratory#Entr...

Can you please provide a source to this?

Geometric constraint solvers are essentially graphical, declarative domain-specific languages for mechanical/physical design. As an example: http://solvespace.com/index.pl

So do you need for images, photos, spreadsheets, PDF files, websites, schematics, board layouts, databases, mechanical drawings and models, neural network models, music masters, audio tracks, video footage and any other file format used by professionals.

Better yet, all the formats I mentioned are raw text and not even binary. And all have well developed tools for editing.

> I think that'd be useful for commenting but nothing else.

But isn’t that a good enough use case?

Almost nobody bothers to put proper formatting, diagrams, tables, formulas, references etc in their source code. At best we get ASCII approximations.

To see some examples of what it could be like look at Mathematica, Jupyter, literate programming, and org-babel.

They kinda are a non-profit. They are, AFAIK, a _forening_ (translates to association), which allow them to collectively own assets and collect donations.

It depends on what you are looking for. Docco and friends seem to only be capable of reversing the relationship between comments and code.

However, they don’t allow you to structure the program however you might like independently the need order and _nesting_ of code. In a lot of cases you can get around this through appropriate design patterns.

I’ve recently taken a quite deep dive into possible tools for literate programming. I work with signal processing so code documentation is extremely important but also frustratingly challenging.

There are a lot of “old” tools for literate programming (noweb, FunnelWeb), and they all lack in platform support, but are exceptionally stable and quite pleasant to work with. The more modern “true” literate programming tools are typically using a form of markdown (no links since my notes are not at hand). The last group are the “coffee script style” tools and they seem to be quite popular and active.

It seems to be a case of natural selection for tooling: true literate programming is serverely disadvantaged in terms of IDE/editor support and the programming philosophy is, unfortunate, too different from the norm. Docco styles seems highly pragmatic in contrast.

One option I haven’t tried yet is Emacs’ org-mode which includes true literate programming support. I haven’t found much with regards to real-world usage.

fpmagic looks quite interesting -- very barebones, but at least its a start!

Footwork too looks like a neat project and I especially think the closer connection between code and interaction is beneficial. It is the same thing which impresses me about libfive and the whole stack around it: it is not just a GUI, not just a scripting language, not just an API -- it is all at once!

From my research into available libraries for geometric constraint solving the best choice is probably SolveSpace. It is actively developed and fast. However, I haven't yet put action behind my thoughts and I'm willing to try things out and make some progress.

Interestingly I am myself doing a Ph.d. in photonics engineering, but I am almost entirely in signal processing and information theory.

Anyway, thanks for the links and the thoughts! Amusingly almost all of the links were already visited! I've looked several times at your library for geometric constraint solving in Python and almost thought about using it for my own projects. In the end however I think SolveSpace is the best choice -- it is solid, actively developed and fast.

Your ambition of having the drawings be singularly specified by their constraints is absolutely admirable, but from my experience it is simple not feasible nor desirable. First, the optimization problem is difficult to solve and it will be difficult to specify it such that there is only one unique solution. Secondly, I think the human provided prototype (through a GUI) is a critical part of the design process which makes this technology usable. But I understand the desire to have drawings specified only by constraints.

In the long term, if I am allowed to dream, I'd like to see the development of a more general purpose constraint-based and parametric drawing library. Right now I am focused on PCB footprints, but many of same ideas are useful in electrical diagrams, optical diagrams, GUIs, page layout etc etc. We'll see how far I get ;)

A particular flavor of constraint solving is geometric constraint solving, where constraints such as "this line is parallel to this line" and "this line is tangent to this curve". This is widely used in pretty much everything single mechanical CAD tool worth its salt.

But you know what it is missing from: electrical CAD tools.

For footprints this would be especially useful. Some think that footprints are just one size fits all, but that is far from the truth. Footprints should vary depending on the environment, production tolerances, manufacturing method. Right now I have several varieties of the same footprint for different deratings and uses -- what if I could simply specify a parametric footprint which actually adapted to specifications made in the design process.

This could be done with wizard programs (several commercial options exists), but I think an approach based upon geometric constraint solvers and parametric drawings is a far, far more user-friendly and powerful approach. The widespread usage in mechanical CAD tools prove that this is not a far-fetched application; it simply hasn't taken a foothold within electrical CAD tools.

I've been toying with the ideas and researching how it could be done for quite a while, but I haven't made much code-wise progress yet. However, there is a lot of tools to draw upon (libraries for geometric constraint solving exists). If someone is interested in co-developing on some ideas, or already knows of such a project, then I'd love to hear about it (email is in profile) -- I'm getting tired of manually calculating grid sizes and offsets.

Not everything is written in C. On a project I recently worked on we opted for Linux on the embedded platform to support some 3rd party tools and allow ourselves to work in easier-to-prototype languages.

Additionally, the management of the device is now “just Linux”, which is fairly Elmore well known.

——

In retroperspective, I don’t know if I would do it in the future. There are definite advantage in using Linux, but there is also a lot of work involved in understanding Linux and keeping track of the platform. That is true for a simpler OS, but I feel it might be more manageable.

This is one of the most actively researched fields in computer architecture/engineering. Hard real-time requirements has been been extensively researched for ISAs, compilers, network-on-chips, concurrency models etc etc.

Personally, I was briefly involved in the T-CREST[0] project where a complete ISA, network on a chip and compiler where devolved in tandem to support deterministic timing and well understood worst case execution times (WCET).

As an example, the ISA explicitly defines multiple caches with different write-rules. So for example the stack cache is write-back to lower WCET.

The whole project is available as a VM image[1] where the HDL can be compiled to an emulator and/or synthesized to hardware.

[0]: http://www.t-crest.org/page/overview [1]: http://patmos.compute.dtu.dk

Which is a quote based upon a quote by Alan Shepard[0].

[0]: https://en.wikiquote.org/wiki/Alan_Shepard

The technical university of Denmark also transistioned to teaching computer arch using RISC-V. Some of the most popular textbooks are also being converted to RISC-V editions.

Rebol and Mathematica/Wolfram Language are two other that come to mind. Albeit Wolfram is kind of a Lisp. Possibly also Lua and its tables concept.

With const generics ranged integers would be implemented as a user specified check.

How viable would it be to implement an optimization step which seeks to minimize the number of these checks?

Note that RISC-V is _not_ an open-source processor, but an open-source instruction set architecture.

Which means that anyone can implement the instruction set and thus many different implementations can be made. Most likely there will not be one common and shared processor.

Do you know how the process was adopted at the employer?

What tools would you recommend for the actual tangle process? Noweb?

What programs do you use? Can they make annotations with math typesetting, markup, links and images?

You are replying to the person who proposed the “lose copyright” idea.

But even these are approximations and false gods.

Electromagnetism and solid-state physics are more fundamental still.

Are the weights in the NN “relating to an identifiable person who can be directly or indirectly identified in particular by reference to an identifier”?

If not, then it isn’t personal information.

It is simple. You have to apply reasonable measures to delete the data.

That is vague, for sure, but hopefully you have the engineering skills and domain knowledge to make a good call.

Dealing with credit card data? Think a lot about it.

Dealing with movie preferences? Deleting from the database should be adequate.

Dealing with attendants from a local conference? Delete the files when you don’t need them.

(And remember: nobody will ever show up with a fine one day. It will always start with a warning and a chance to improve before any fine is applied – unless there is serious neglect.)

They are treated the same because you are collecting data about others and GDPR regulates how this should happen.

If you want to collect the data, then it must relevant for your business and that warrants you should treat it properly.

Upon request to erasure you should go use reasonable measure to remove it. Wiping your memory is absurd and is never considered reasonable – no need for a lawyer to rule that out.

What makes you think that? Why do you intentionally spread absurdities?