If desired, I can comment your document over a private channel. In that case, please give a short heads-up when ready.
Note that I am not directly affiliated with WG14. So take my comments with a grain of salt.
1,707 karma · joined March 5, 2014
Note that I am not directly affiliated with WG14. So take my comments with a grain of salt.
http://www.open-std.org/jtc1/sc22/wg14/
Since UB allows the compiler to do anything in those situations, we can reduce the amount of UB without breaking existing “legal” code. By actually defining more behavior.
If a proposal is reasonable needs to be discussed in the standardization committee. All other discussions are a nice hobby. But eventually moot.
It is rare to see such lucid communication and such a clean commit history for hard technical development.
http://git.savannah.gnu.org/cgit/guile.git/log/
https://lists.gnu.org/archive/html/guile-devel/2018-05/msg00...
In a few years, all the cool kids will switch from Graal to Guile for language development.
https://unix.stackexchange.com/a/223763
With regards to POSIX, it is amazing how well this API is holding up. There are quite a few implementions from GNU, BSDs, Microsoft (at least partial support in MSVC) and a few others (e.g. musl). So POSIX support is a given on most systems. Why replace it with something that breaks existing code?
https://www.musl-libc.org/faq.html
Not to say there is no bloat. But some bloat is the patina that all succesful systems take on over time. Is the bloat small enough to be managed and/or contained? I say yes.
In addition to the other Gilbert Strang ODE courses, this one comes with videos for numerical solutions. From the inventor of Matlab himself.
- Differential Equations from 2015: https://ocw.mit.edu/resources/res-18-009-learn-differential-...
- The original SICP recordings from 1986: https://ocw.mit.edu/courses/electrical-engineering-and-compu...
The patents and registered designs of ETA movements have expired. You can buy exact clones of ETA movements legally.
ETA clones by Sellita and Soprod are said to be better than the original. Sea-Gull (and other Chinese) aren't bad either. Especially for the price...
You don't need constraints for the bounds. That's the beauty of it.
The idea is to sample from the domain and use Lipschitz bounds (or a semi-metric in the cited paper) to upper-bound the target function via the distance to the samples. The question is how take samples in a principled way that garuantees a "good" speed of convergence.
There is no free lunch. So some assumptions have to be made on the non-convex target function. However, a semi-metric around the optimizer is much weaker assumption than a Lipschitz constant. The function doesn't even have to be continuous!
Of course performance is a lot slower than, say, linear programming. But this is non-convex optimization, a much harder problem.
This has gotten a lot better with static code analysis (clang-analyzer, Coverity, ...) and whitebox-fuzzing (libfuzzer, afl, ...). Both simply point you to the bugs and don't require a formal spec.
Together with Valgrind, these tools have revolutionized C programming for me.
Most non-convex optimization with bounds for the convergence speed exploits on some sort of structure. For example Lipschitz bounds for the gradient. There is some recent work that requires only a semi-metric around the optimizer. That opens up a large class of functions that could not be efficiently optimized before.
http://papers.nips.cc/paper/4304-optimistic-optimization-of-...
Read these and you are on the edge of what is currently happening.
There is an entire community dealing with "AI planning". They try to find action-sequences leading to a desired outcome. Every action is defined by preconditions and effects. Most of the benchmark cannot even be sensibly formulated in terms of a mixed-integer optimization problem.
This seminal paper is a good entry-point to the field: http://www.jair.org/media/1705/live-1705-2731-jair.pdf
A bit of background research would do good before calling the problem at the center of a very active community "childish".
The kernel could be ported piecemeal while always being able to boot during the transition. Similar to how remacs is slowly porting emacs over to rust [2].
And on top of that, you can use the rump kernel approach to run the device drivers, TCP/IP, etc. from NetBSD. So you immediately get a fully functional OS.
Since you are not doing sports 95% of the time, this has a lot of leverage. And you can build muscle with 30min of training per day easily.
Also, you please check whether you mean kilocalories when you say calories.
I know ntpsec is a somewhat questionable fork. But the refactoring work itself can't be all bad...
Leaving some technicalities aside, SQLite is SQL. So I guess we're not talking the same here.
A workaround is a plugin mechanism with dynamic loading of .dll or .so libraries. But that won't fly on a microcontroller.
Afaik, kcc is also really good at finding undefined behavior. Regehr even wrote about it in the past (https://blog.regehr.org/archives/523).
“If you’re arguing, you’re losing.” — Mike Thomas
A shouting match doesn't help anybody. A civilized exchange of arguments does. And the establishment of evaluation criteria is a very good basis for listening to the other.
The not-arguing approach often times results in "let me show the merits of my technology without listening to your requirements / evaluation criteria".
C is different from C++ because it targets different use cases. So it needs to be evaluation in the context of use cases. End of story.
The amazing part is how little cleanup work is required to make the code work. It's an entire programming language after all!
Europeans don't want the US playing global super power. They don't need it. And they ain't paying for it.
And the US are not paying $$ for anybodys army. And they know very well how to use their own capabilities outside of NATO and for their own interests.
More military interventions with more refugees arriving at European borders?
There is basically no real threat to European countries atm. Russia is heckling a bit in Ukraine. Supplying Kalashnikovs to separatists and such. But in general, Russia is retreating. With Montenegro joining NATO and things going bad in Syria, Russia is losing access to the Mediterranean sea. And they run out of money quickly!
If things go wrong, special forces (a few hundred men) and French atomic missiles pose enough of a threat for rogue dictators. The large countries can't afford a war, because economic ties are too strong.
Military spending in Europe is exactly where it needs to be. Low. Humanitarian help throughout the world and keeping the inner stability of society (social security, health-care, retirement, ...) gives a lot more bang for the buck. (pun intended)
https://ocaml.org/learn/books.html
https://wiki.haskell.org/Books
It could well be, that these books are written for experienced programmers who don't need basic concepts (control flow, object orientation, etc.) explained. But that was not the point.
The absence of an easy road for these langauges is because they need to teach some powerful abstractions first that have no equivalence in Python, Java or C.
Have you tried functional programmng? Lisp? Ocaml? The complaints of newbie functional programmers are also nearly the same.
The "struggle" is necessary. If there is no struggle, there is no learning of fundamentally new approaches you are not yet comfortable with.
See it as part of the training regimen that lets people emerge as stronger programmers on the other side.
A function that tests for something involving its arguments
is called a predicate and usually ends in p or -p.Last thing I heard was that Guile-Elisp (and by consequence Guile-Emacs) is working, but very slow. That can be fixed but requires work. Also, Emacs internally uses a different string representation from Guile. This makes the transition between languages tough and some more glue is required.
IMHO Guile-Emacs is "nearly there". I.e. with just a little more work it could have enough momentum and attract developers to be on the trajectory of becoming the default elisp implementation in the long term.
Having the new Guile 2.2 VM drive Emacs would definitely improve things. And the C-codebase could become considerably smaller and cleaner.