9 ms·
The Oberon+ Programming Language
- codetrotter 4y agoAny relation to the Oberon operating system? https://en.wikipedia.org/wiki/Oberon_(operating_system) https://en.wikipedia.org/wiki/Oberon_(operating_system)
- sfpotter 4y agoI don’t like how verbose Pascal-like languages are. I don’t want to have to type tons of keywords to get anything done. Curly brackets are a big improvement over pairs of “begin” and “end” all over. Makes it hard to see the forest for the trees when skimming some code to figure out what it does. That on its own makes something like this a complete nonstarter for me, leaving aside issues like support, quality of implementation, uptake, etc.
- nequo 4y agoI think it's less about typing them and more about reading them. Curly braces reduce the number of keywords in the language (unless the alternative is indentation sensitivity like in Python or Haskell). This means that if I see a word, it is easier to infer if it is a variable name or if it does something structural. How about a treesitter-based editor extension that converts between begin/end and {/}, as if they were ligatures? Actually this might not even need treesitter.
- armchairhacker 4y ago> How about a treesitter-based editor extension that converts between begin/end and {/}, as if they were ligatures? Actually this might not even need treesitter. See emacs prettify-symbols-mode (https://emacs.stackexchange.com/questions/46529/configuring-prettify-symbols-mode https://emacs.stackexchange.com/questions/46529/configuring-...)
- xigoi 4y ago> How about a treesitter-based editor extension that converts between begin/end and {/}, as if they were ligatures? Actually this might not even need treesitter. Neovim has the conceal feature, which can convert Treesitter nodes into a single symbol, but not the other way around unfortunately.
- cxr 4y agoI'd rather have systematic "language skinning", where different flavors (begin and end versus { and }) are isomorphisms of each other so one's tooling can fluidly translate between both forms. Rochus is almost kind of doing this with Oberon+ versus Wirthian Oberon already, but it would be nice to go further.
- pjmlp 4y agoCode is read much more times than written, and hieroglyphs don't help.
- LudwigNagasena 4y agoAd hoc hieroglyphs that change from project to project indeed make it harder to read code. But as long as they are the core part of the language and they represent orthogonal features (ie they don’t bloat the number of ways you can represent identical solutions), I don’t see why it should be a problem. On the contrary, putting less visual weight on tokens with smaller information content looks natural.
- zabzonk 4y agoso, you recommend cobol?
- canadianfella 4y ago[dead]
- mpweiher 4y agoActually they do, particularly for reading, as they separate language boilerplate from actual content. For example, to call a function, we just use the name of the function and parentheses, rather than saying "call". This is useful, because it allows the reader to focus on what is of interest.
- zabzonk 4y agoapart from that (which i agree with) is that in most pascal-like languages you have to define variables at the top of a function, and their scope is the whole function. both c (nowadays, define at top of a {} scope) and c++ (define anywhere inside a function) do much better which, together with irritating long names, may explain why c and c++ won out over the pascal-likes. speaking as an ex professional delphi programmer here - i have written lots of object pascal code, and have no desire to write any more.
- unwind 4y agoC is declare anywhere and has been for a looong time (C99).
- zabzonk 4y agosorry, my bad, i don't do any c programming these days. but to be pedantic, i think you mean define rather than declare, though of course you can also declare things at different scopes.
- stefncb 4y agoNo, I think they do mean declare. In C89 you can define a variable anywhere, like so: int x; f(); x=3; The improvement was allowing declarations anywhere.
- rightbyte 4y agoIsn't the first row both the declaration and definition is this case? (I assume f() is a call.)
- Jtsummers 4y agoC (and C++) considers the declaration to be separate from the definition, though you can combine them. The declaration is the name + type, definition provides a value. The example code is meant to illustrate separate declaration and definition with some code (the call to `f`) between the two. If you try to use `x` before it is defined (the assignment) your compiler should give you a warning, at least. If it doesn't, find a new compiler.
- cardanome 4y agoFor me, "begin" and "end" are actually much more comfortable to type, because I don't have too move my hands for that, I can stay pretty much on the home row. Curly Braces are way too far on the right top to do that and then you either have to use you weak fingers or move quite a bit. (Granted I am touch typing and also using Colemak layout, so rarely ever move my hands. For people that hunt and pek, I believe curly braces are easier to type.) I don't think there is much practical difference between curly-braced vs keyboard based syntax. Both are similarly easy to read, especially with syntax highlighting. After a while, your brain will automatically parse "begin" and "end" as a symbol, same as curly braces, so you won't notice the "noise". As for the pros and cons: Pascal style syntax is slightly better for new people learning to program. Learning how to even type those weird curly braces and understanding the difference between all the styles of braces just takes focus away from actually learning how to program. Curly braced C-style syntax is better for people that already know how to program because everyone is already familiar with at least one curly braced language.
- zabzonk 4y ago> because everyone is already familiar with at least one curly braced language. so, logically, they must have learned how to use {} in the first place, probably with few problems. i have taught god-knows how many people c and c++ (used to be a commercial trainer for those languages) and i can assure you that very, very few, if any, had problems with {}.
- 082349872349872 4y agoA normal swiss keyboard does not even have {}
- iroddis 4y agoI also find curly braces/parens/etc annoying to type, but recently had my mind blown when I saw a typing tutor program that recommended using left-shift to create those characters. For 35+ years I’ve been using right-shift for things on the right side of the board, cranking my hand and stretching my fingers and complaining about programming languages with poor typing ergonomics. It’s taking forever to break the habit, but so far it feels so much better.
- timbit42 4y agoPascal required BEGIN and END for every block, such as: IF <cond> THEN BEGIN <code> END ELSE BEGIN <code> END END, but Modula-2 and Oberon don't require BEGIN or END around code blocks: IF <cond> THEN <code> ELSE <code> END. BEGIN is now only used to denote the end of variable declaration and the beginning of the code. You can see this if you click the posted link. I think it was a valid complaint in Pascal, but not in it's derived languages.
- shadowofneptune 4y agoIf you've dismissed a whole host of languages just at a glance, you're missing out. Lua has little in common with Pascal, which has little in common with Fortran, etc. As a sister post to this says, you see them more as tokens once you are familiar. Emboldening or coloring keywords also helps, as for any language.
- bluedino 4y agoThat seems like it would be a simple thing to change.
- sedatk 4y agoI'm actually okay with begin and end, but, writing a function's name twice on both the declaration and after the end statement sounds like a HUGE chore. If that's mandatory, it's immediately a mood killer for me about Oberon+.
- chadcmulligan 4y agoThe idea was you have all the methods on the object available in a small list, and (originally at least) it aided one pass compiling. Delphi continues this and in the IDE you can just go Ctrl-Shift-C in the definition and it will fill out all the method implementation boilerplate automatically, you can then ctrl-click between the implementation and definition. It is useful, say you're in a method body, you ctrl-click to get to the definition, then ctrl-click to the next implementation body you want to code. It means the code is easier to find than in say something like C# or even swift where you can have methods all over the place.
- sedatk 4y agoNo I meant this: proc Something() begin ... end Something not the interface/impl declarations. Which actually makes this worse.
- chadcmulligan 4y agooh ok, yeah that's not pretty
- revskill 4y agoThe funniest thing i see is programmers are getting prroblems to grok functional programing concepts.
- themodelplumber 4y agoI thought the background context by the author was interesting to read: https://oberon-lang.github.io/2021/07/15/motivation-for-a-new-oberon-version.html https://oberon-lang.github.io/2021/07/15/motivation-for-a-ne...
- srean 4y agoI was looking for coroutines. Modula had them, but I couldnt find them here. Just a note I mean coroutines, not preemptive threads. Here is how it looks like in Modula-2. https://www.modula2.org/reference/isomodules/isomodule.php?m=COROUTIN.DEF https://www.modula2.org/reference/isomodules/isomodule.php?m...
- mikewarot 4y agoI did coroutines under Turbo Pascal wayyyyy back in the 1980s[1]. It's really just a matter of copying the stack and some book-keeping. Free Pascal has threads. [1] https://www.pcorner.com/list/PASCAL/TASKER4.ZIP/TASKER.PAS/ https://www.pcorner.com/list/PASCAL/TASKER4.ZIP/TASKER.PAS/
- tragomaskhalos 4y agoFor anyone wondering about the funky asterisk against some of those identifiers, the docs say: An identifier declared in a module block may be followed by an export mark (* or -) in its declaration to indicate that it is exported
- jhbadger 4y agoThis is from normal traditional Oberon, however.
- ZoomZoomZoom 4y agoOberon and Oberon+ are very interesting and are certainly a step forward from Pascal. Wish Oberon+ had moved forward a few more steps, like making everything an expression, for example, or more lax variable declaration rules (which probably require scoping rules changes). If only the FPC compiler supported it and allowed combining units in Oberon with Pascal ones in one project! The language specs: https://github.com/oberon-lang/specification/blob/master/The_Programming_Language_Oberon%2B.adoc https://github.com/oberon-lang/specification/blob/master/The...
- shadowofneptune 4y agoYou appear to be familiar with Pascal, so I am surprised you find the statement-heavy approach an issue. What would be the benefit of making this change?
- ZoomZoomZoom 4y agoMy Pascal days are far in the past, but I recently used Lazarus to quickly prototype a simple GUI app (not many tools beat it yet for the task) and was a bit annoyed by the syntax. Relying on expressions greatly reduces the need for transitory variables, and in case of Pascal, where you can't just declare them as you go, this would be especially important to clear the code from ops inessential to the task at hand. `let foo = if (bar > 0) then bar else frobnicate() end` would be nice to have, as well as begin-end blocks with their own scope (can't fathom the reasons it's not allowed) and evaluated to the last statement. Rust and Nim get it mostly right.
- shadowofneptune 4y agoThis does feel then like a matter of taste. While Pascal's predecessor language Algol did allow syntax like that, adding it back to Pascal-like languages would make it into a different kind of language.
- ZoomZoomZoom 4y agoWhat makes the language what it is is rather a philosophical question. I don't think I agree with you on this specific point. I'm not against evolution, especially when you have others to test the feature extensively for years. But I'm not a language designer and my opinion on the matter holds no weight.
- carapace 4y agoThe whole Oberon system is great fun. https://people.inf.ethz.ch/wirth/ProjectOberon/index.html https://people.inf.ethz.ch/wirth/ProjectOberon/index.html It's a single-user workstation, developed from the CPU on up, compiler & language, OS with unique GUI, all documented in a book, and you can run it online in a browser via a JS emulator for the CPU: http://schierlm.github.io/OberonEmulator/ http://schierlm.github.io/OberonEmulator/ People used it at ETH as their main system to run the University!
- alex_suzuki 4y agoI studied CS at ETH from 2001 to 2006. Oberon was the main language used for teaching our introductory CS courses IIRC. Fun times. :-)
- pjmlp 4y agoNote that the evolution of it was Active Oberon and AOS operating system, much more closer to modern languages and OS stacks.
- illiarian 4y ago> During my work with Oberon and systems implemented in Oberon, I kept asking myself what properties the language would need to have so that I could use it for my own systems too, without giving up the goal of making it as simple as possible. From here: https://oberon-lang.github.io/2021/07/15/motivation-for-a-new-oberon-version.html https://oberon-lang.github.io/2021/07/15/motivation-for-a-ne... And yet it carries over all of the inanities of the many Oberons before it like: - Four different loops (while, for, repeat, and loop) - Useless distinction between procedures and functions - Randomly selected ASCII symbols to show what is exported and/or read-only - extremely awkward and limited exception handling (you have to call a procedure that cannot hav a return type using a built-in pcall procedure that writes exception info into a variable you pass into it) and so on. All of Oberons are just walking around in circles re-implementing the same weird ideas again, and agian, and agian, and again.
- timbit42 4y agoI like having a few different loops to keep code more readable. I think there should be two at a minimum for whether the condition is before or after the looped code. I agree with the rest, but the rest of the language is great.
- illiarian 4y ago> I like having a few different loops to keep code more readable. When they have similar semantics, and are not arbitrarily designed. In Oberon: - while has an elseif statement. Repeat is a do/while, doesn't have an elseif statement - loop is allowed an exit. No other loops are allowed to terminate early. And that is literally the only reason loop exists etc.
- layer8 4y agoThe last point is very likely by design: Only when you see a LOOP do you have to worry about early exits. For the other, more common constructs, you instantly know there won’t be an exit somewhere in the middle, and you can reason about its termination behavior solely based on the loop conditional.
- luixmg 4y agoIs this what it used to be component Pascal?
- rurban 4y agoNo, much younger. See https://oberon-lang.github.io/2021/07/15/motivation-for-a-new-oberon-version.html https://oberon-lang.github.io/2021/07/15/motivation-for-a-ne...
- deleted 4y ago[deleted]
- dang 4y agoRelated: Show HN: New Oberon+ to C99 transpiler for near native performance - https://news.ycombinator.com/item?id=29591993 https://news.ycombinator.com/item?id=29591993 - Dec 2021 (2 comments) The Oberon+ Programming Language - https://news.ycombinator.com/item?id=27864582 https://news.ycombinator.com/item?id=27864582 - July 2021 (4 comments) The new Oberon+ programming language – modern simplicity - https://news.ycombinator.com/item?id=27855767 https://news.ycombinator.com/item?id=27855767 - July 2021 (4 comments) Others? (Lots of original Oberon, of course)
- stefanos82 4y agoFirst time I read about Oberon was when I saw Ginger Bill presenting Odin language and visited his website to learn more. It was when I visited its FAQ [1] that saw the major influences that inspired him to design a new language and one of them was Oberon-2 which is an extension to Oberon itself. Fascinating stuff! [1] https://odin-lang.org/docs/faq/ https://odin-lang.org/docs/faq/
- hsn915 4y agoYea I was going to comment and say if anyone is interested in a modern language the follows in the tradition of Pascal/Oberon they should look into Odin
- olah_1 4y agoI really see how Nim was influenced by Oberon now. Will Oberon+ actually compete with Nim in some ways?
- Rochus 4y agoThat's like competing apples with oranges; some people like the former, some the latter, some both; if you prefer a Python like syntax an a much more complex language, then Nim is your choice.
- sitkack 4y agoI have so much respect for the design aesthetic of Wirth, but I don't like OO. What would a Wirthian FP language look like? I asked the oracle > Wirthian functional programming language would emphasize simplicity, elegance, and readability while incorporating functional programming concepts such as immutability, first-class functions, and recursion. It would provide strong typing, modularity, and a minimal standard library, staying true to Wirth's design principles. It also tells me that Elm, Idris, PureScript, F* and Gleam share many of these same qualities. The thing that I didn't appreciate about the design of Wirthian languages earlier is that he really focused on mechanical and compiler-writer sympathy, designing languages that were fast and easy to compile. I just discovered Pascal-S, it is like Cool or ChocoPy, a subset language designed for compiler students to implement. https://static.aminer.org/pdf/PDF/000/530/289/pascal_s_a_subset_and_its_implementation.pdf https://static.aminer.org/pdf/PDF/000/530/289/pascal_s_a_sub...
- pjmlp 4y agoEasy, Standard ML.
- xkriva11 4y agoI like it is not using uppercase keywords. Is the grammar still LL(1)?
- Rochus 4y agoIt's mostly LL(1) with a few LL(2) and one LL(k) productions.
- sacnoradhq 4y agoIf you want a scalable GC: - Don't throw everything into a single global heap - Don't rely on stop the world GC - Support actors and zero-copy message passing .. in other words, be like Pony's ORCA.
- skybrian 4y agoThe justification for putting generic types on modules is interesting. It seems they tried a lot of other variations but couldn't find one that was simple: https://oberon-lang.github.io/2021/07/17/considering-generics.html https://oberon-lang.github.io/2021/07/17/considering-generic...
- badsectoracula 4y agoA few years ago i was also thinking of how Oberon-07 could be extended to support more generic types - mainly so containers, etc, can be more type safe - and pretty much came to the same conclusion that putting types on the modules themselves is by far the simplest approach. Though my approach was a bit different (judging from the code examples) in that parametric modules were more like templates that were specialized during import. Specifically in Oberon-07 when you have a module "Foo" with a type "Bar" you use it in another module as "Foo.Bar". With parametric modules, a "Foo<T>" module would need to be imported an a specialized form as -e.g.- "Foo<INTEGER>" and thus the "Bar" type would need to be used as "Foo<INTEGER>.Bar". In my mind that was both the simplest and smallest change that would allow for the most flexibility (the parameters would be any token acceptable by the language, not just types, meaning that they could be used for constants or even affect other imports). I did consider implementing a compiler for this, but then i decided that if i'm going to make a compiler for an incompatible language that already practically nobody uses, might as well make my own language that also changes some things i dislike about Oberon-07 (like the uppercase keywords, using # for the inequality string and * to export stuff from modules).
- xiaodai 4y agobut why? what would i use Oberon+ for? I used pascal and delphi in the past but for r, python, julia i can use for data science, js/ts for web dev, and python for general stuff. what's oberon+ for?
- imtringued 4y agoSeeing pascal syntax for the first time, I was confused why it looks so overly verbose, like VHDL. It turns out that it was Pascal that rubbed off onto VHDL. However, this makes me think that pascal style syntax is a very poor choice for software development.
- timbit42 4y agoIt's more readable than innumerable symbols like in C++ or Rust.
- fnord77 4y agothat Fibonacci implementation has exponential complexity
- H4ZB7 4y agolooks like an absolutely uninteresting boomer language, by the fact that it just shows standard imperative stuff followed by "wow it supports unicode, we are up to date"! (which is a misfeature, btw, i like being able to audit my code before running it (not that thats possible in the current mess of misconceived computers but yeah still it would be good to start doing things in the right direction). its interesting that there is supposedly an os in oberon that actual uses the same language for the shell or something or the kernel is written in it or something like that but this page just makes me think its not worth looking into after all
- xigoi 4y agoSyntaxError: expected ')', found end of comment How does Unicode support make it harder to audit code?
- cxr 4y ago> oberon that actual uses the same language for the shell This is a common misconception. Oberon's text-based user interface lets you invoke commands in the M.P form, but it doesn't really have a shell language—at least not in the familiar sense—and to the extent that something like one kind of exists, it certainly isn't the same as Oberon-the-language.