https://de.wikipedia.org/wiki/Visual_Basic_for_Applications?...
644 karma · joined June 3, 2017
https://de.wikipedia.org/wiki/Visual_Basic_for_Applications?...
- Puzzles: Sudoku, St8ts
- Bridge crossing: Missionaries and cannibals, 17 minute bridge crossing (I need a computer to solve this anyway)
- Concurrency: finding bug in mutual exclusion algorithm (Peterson algorithm with a bug)
- Graphs: coloring a map, finding a Hamilton path
- Sorting: Finding bugs in a sorting network
For many students it was difficult to encode problems in SAT. They seemed to understand given example encodings, but then found it difficult to vary them. There is a lot of freedom in how one may encode things and it's hard at first to debug at first when things don't work in the way you're expecting. If there is no solution, then one needs to investigate where there are unwanted constraints or errors in the encoding. If there are unwanted solutions, one needs to identify the missing constraints. It was hard to get across how to do this and it's probably frustrating for beginners.
I've had this happen and it really grinds you down when you work full-out for months and, just when you think you've contained all the crises, the next one drops.
The old German Diplom system (replaced by BSc/MSc about 15 years ago) was based on oral exams. The way this worked there was that there were much fewer exams. For example, in Computer Science I had my first oral exams two years into the degree, and there were only five of them: one in Mathematics, one in each of Theoretical, Practical and Applied, Computer Science, and one for the second subject. Each of these oral exam was 30 minutes but covered the content of four semesters. There was a second round of such exams at the end of the degree and that was it.
To be admitted to an oral exam, one needed to pass the courses that the exam was going to be about. Lecturer were free to set the passing requirements. It was often just something like a coursework threshold of 60%.
https://www.universityworldnews.com/post.php?story=202207262...
https://europa.eu/youreurope/citizens/consumers/internet-tel...
At the time they were doing functioning mockups for the Aqua design in Macromedia Director. It was not easy to actually implement the UI with the available hardware, but the mockups showed that it was possible. "Mr. Ratzlaff frequently would remind Apple engineers that 'Macromedia can do it, so why can't you?'"
Only source I can find is: https://www.macobserver.com/article/2006/03/15.9.shtml
> As it so happened, Mr. Ratzlaff and his team had already been working on a ground-up redesign of the operating system after they discovered that their original goal of porting the look-and-feel of Mac OS 8 completely to Mac OS X would be impossible. "We were only going to be able to get about 95% of the way there [putting the Mac OS 8 interface on Mac OS X], which is possibly the worst thing you could do," Mr. Ratzlaff said. The redesign had been scrubbed by higher-ups at Apple but was put back on track by Mr. Jobs.
> With that, Mr. Ratzlaff and his team's list of requirements for the operating system, which had been called overly ambitious and led to laughter from engineers who heard of them only weeks prior, became mandatory. These included 32-bit color with alpha channels and QuickTime integration, all being able to run on a system with just a G3 processor and as a little as 8MB of video memory. Mocking up the operating system's design and functionality with Macromedia's Director, Mr. Ratzlaff frequently would remind Apple engineers that "Macromedia can do it, so why can't you?"
So, while id id has type ('a -> 'a) -> ('a -> 'a), this is stored in memory by a pointer structure that amounts to let 'b = ('a -> 'a) in ('b -> 'b). The type of id id id would become let 'b = ('a -> 'a) in let 'c = ('b -> 'b) in ('c -> 'c). This grows linearly. If one were to write out the types without sharing then their size would grow exponentially.
OCaml:
let x1 = fun y -> (y, y) in
let x2 = fun y -> x1 (x1 y) in
let x3 = fun y -> x2 (x2 y) in
let x4 = fun y -> x3 (x3 y) in
let x5 = fun y -> x4 (x4 y) in
let x6 = fun y -> x5 (x5 y) in
x6 (fun z -> z)
Haskell: test = let
x1 = \y -> (y, y)
x2 = \y -> x1 (x1 y)
x3 = \y -> x2 (x2 y)
x4 = \y -> x3 (x3 y)
x5 = \y -> x4 (x4 y)
x6 = \y -> x5 (x5 y)
in x6 (\z -> z)
If you can compile these, add x7. The effort increases exponentially as one adds x7, x8 and so on.One thing to note is that this is a Trabant 1.1 not a 601. The 1.1 was produced only from 1990 to 1991 and had a four-stroke VW engine (produced under license from VW). So the sound in the video is not the one typical two-stroke engine of the standard 601. The appearance of the car is very similar to the 601, though.
This reminds me of "Rubbish bin the likely source of Covid infection": https://www.rnz.co.nz/news/national/427446/rubbish-bin-the-l...