Oberon parser, code model & browser, compiler and IDE with debugger (by rochus-keller)

Oberon Alternatives

Similar projects and alternatives to Oberon

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better Oberon alternative or higher similarity.

Oberon reviews and mentions

Posts with mentions or reviews of Oberon. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-09-23.
  • Useful lesser-used languages?
    9 projects | reddit.com/r/ProgrammingLanguages | 23 Sep 2022
    Oberon? see https://github.com/rochus-keller/Oberon/
  • Ask HN: What programming languages are you excited about?
    3 projects | news.ycombinator.com | 16 Sep 2022
  • What do you think about a C transpiler?
    6 projects | reddit.com/r/C_Programming | 12 Sep 2022
    My Oberon compiler (https://github.com/rochus-keller/Oberon) does exactly that. But the C transpiler is only used when development and debugging are done, because debugging based on the generated C code makes everything much more complicated and platform dependent. Instead my compiler also generates CLI IL so I can use the excellent, lean, and cross-platform Mono engine integrated with my IDE re-using the Mono performance and debugging features; this is transparent to the developer; just in the end he/she generates (platform independent) C code and compiles it using e.g. GCC, CLANG or MSVC.
  • Thoughts on building on a VM (in particular, .NET/CLR) but not "exposing" the underlying VM?
    4 projects | reddit.com/r/ProgrammingLanguages | 20 Aug 2022
    Interesting, thanks for the links, I will have a look at them. I used both the J2EE and .NET frameworks in the past. My major current interest in .NET is the CLR and CIL which I use in https://github.com/rochus-keller/Oberon/. I wouldn't switch since the Mono CLR is very good, but if there was a lean, improved version of the JVM I might consider generating bytecode for it.
    4 projects | reddit.com/r/ProgrammingLanguages | 20 Aug 2022
    That sounds rather similar to what I did with my Oberon+ implementation (see https://github.com/rochus-keller/Oberon/). I'm using Mono instead of CoreCLR, because it is leaner and runs on more architectures. Some versions of Mono turned out to be even faster than CoreCLR (see https://www.quora.com/Is-the-Mono-CLR-really-slower-than-CoreCLR/answer/Rochus-Keller). My Oberon IDE includes the mono executable plus the mscorlib.dll (together less than 10 MB); the IDE communicates with the mono debugger via the official socket interface.
  • Open source vs proprietary compiler
    2 projects | reddit.com/r/Compilers | 27 May 2022
    Did you have a look at Oberon? This is the language Prof. Wirth especially conceived for education of computer science students at ETH Zurich where it was successfully used for many years; also some other universities adopted it. If you don't like the original syntax, there is also a more modern version incl. IDE and debugger, still adhering to simplicity: https://github.com/rochus-keller/Oberon
  • Minimalism in Programming Language Design
    6 projects | news.ycombinator.com | 24 May 2022
    Oberon - the successor of Pascal and Modula - Make it as simple as possible, but not simpler. (A. Einstein) - https://people.inf.ethz.ch/wirth/Oberon/Oberon07.Report.pdf (the whole language guide for Oberon is just 17 pages).

    Oberon to C Compiler - https://github.com/GunterMueller/OBNC

    Oberon+ - Oberon parser, code model & browser, compiler and IDE with debugger - https://github.com/rochus-keller/Oberon

  • KT/COBOL — Choosing a VM edition — I need to hear your experiences with the VM you're currently using for your project.
    6 projects | reddit.com/r/ProgrammingLanguages | 20 May 2022
    Most of my languages have VM backends; see e.g. https://github.com/rochus-keller/Oberon; I implemented different backends generating LuaJIT bytecode; a year ago I switched to Mono which is based on ECMA-335; here is a discussion why I switched: https://github.com/rochus-keller/Oberon/releases/tag/IDEv0.9.0; I implemented utility libraries for both LuaJIT and CIL bytecode; see https://github.com/rochus-keller/LjTools/, https://github.com/rochus-keller/Pelib/ and https://github.com/rochus-keller/MonoTools/. I evaluated many VMs and think the mentioned ones are best suited. There were a lot of challenges with both technologies, what is to be expected, and too much to describe here.
    6 projects | reddit.com/r/ProgrammingLanguages | 20 May 2022
    The CLR has a built-in type system with some predefined types based on which you build your own; the CLR makes a difference between heap and stack allocated types, the former descendants of System.Object, the latter of System.Value; your numbers are likely value types. If you want to understand the CLR start with the standard; I usually use ISO 23271:2012 3rd edition, which corresponds to ECMA-335 5th edition (see https://www.ecma-international.org/publications-and-standards/standards/ecma-335/); I can also recommend the book by Lidin (see https://link.springer.com/book/10.1007/978-1-4302-6760-7). If you want to implement your own runtime library which your compiler generates code for you can write it e.g. in C#, but of course also in IL assembler; and depending on whether you want your runtime to depend on full .NET or just the minimum (mscorlib.dll), you have to take care that your library doesn't depend on things in .NET you don't want to deploy. Have a look on how I did it for Oberon: https://github.com/rochus-keller/Oberon/tree/master/runtime; the directory includes the same runtime written in Lua, C# and C.
  • What are the advantages or disadvantages of compiling to VM Bytecode vs native machine code?
    8 projects | reddit.com/r/ProgrammingLanguages | 17 May 2022
    Compiling to native machine code has many disadvantages such as platform dependency (i.e. you need a backend per platform), much more work (you need e.g. to write the optimizer yourself, likely with different features for each platform, you have to take care of the C ABI yourself in case you need an FFI, you might require a GC, etc.) and it's more difficult to test and debug. If you on the other hand generate e.g. LuaJIT or CIL (ECMA-335) or Java bytecode, all these things are already done for you and the runtime is usually available and optimized for different platforms. If you compile to CIL you can even profit from the AOT compiler features of Mono (or the forthcoming CoreCLR). Some of the mentioned advantages are also available when you e.g. compile to LLVM IR, but the size and complexity is larger and you still have to take care of a lot of things yourself (like GC, C ABI and the like). My early compilers (see https://github.com/rochus-keller/Oberon/) generated LuaJIT bytecode, but then I switched to CIL because of the benefits and instead of an LLVM AOT compiler it write a C transpiler which was a good decision.
  • A note from our sponsor - SonarQube
    www.sonarqube.org | 1 Oct 2022
    Your projects are multi-language. So is SonarQube analysis. Find Bugs, Vulnerabilities, Security Hotspots, and Code Smells so you can release quality code every time. Get started analyzing your projects today for free. Learn more →


Basic Oberon repo stats
6 days ago

rochus-keller/Oberon is an open source project licensed under GNU General Public License v3.0 only which is an OSI approved license.

Truly a developer’s best friend
Scout APM is great for developers who want to find and fix performance issues in their applications. With Scout, we'll take care of the bugs so you can focus on building great things 🚀.
Find remote C++ jobs at our new job board 99remotejobs.com. There is 1 new remote job listed recently.
Are you hiring? Post a new remote job listing for free.