So next we have Fabrice Le Faison and Simon Saubich with GNU Coble, the free software
alternative for Coble.
Thanks for the introduction.
So if you need to just remember one thing from this talk, is that GNU Coble has now
20 years and is ready for industrial use.
He has reached industrial maturity and can compete with the proprietary offers that are
also available.
So let's introduce ourselves.
I am Fabrice Le Faison.
I am the founder of a company called OCamel Pro.
I have been a researcher at INRIA before and I've been in the open source ecosystem for
a long time.
And now I am contributing to GNU Coble since two years ago.
And Simon Saubich is a former, still a Coble developer.
He has been since 2006.
He has been a contributor to Open Coble since 2008.
And now he is the project leader of the GNU Coble project.
So what is Coble?
If you haven't seen a Coble program before, here is a very simple one, Hello World program.
So as you can see, there are three divisions.
One for the identification of the program, then a division for all the storage, so the
global variables and file descriptors and so on.
Here you just have one variable, which is a string of 80 characters with Hello World
inside.
And then you have a procedure division where you have all the statements.
And here you just have one that displays the variable.
So you have seen your first Coble program for a lot of years.
So Coble was born in 1959.
It's a business-oriented language, so it's dedicated just for business.
It's not a generic language.
But he's still evolving almost every 10 years.
There is a new ISO standard.
The last one is from last year in January.
So why Coble matters?
Surprisingly, it's still used in many big corporations.
There are estimates that there are about 80 billion lines of code in the world.
And it's more than for any other language.
It's growing at a rate of between 5% and 15% every year.
And for a lot of corporations, it's just too big to switch to another language.
And another reason why they don't switch is that it's still fast and reliable.
Maybe I can...
So half of me again.
As you have noticed a little bit, it seems to be important because otherwise we don't
have a programming language for this long time.
And as you may have heard, Coble is dead.
I think about every 5 years it's dead and it's still alive.
And it's likely to stay very long because of all this code and all the important thing
it does.
So it's the common saying that if you do use something with your ATM card without knowing
that's not Java, mostly down that's very likely a lot of things that happens in Coble.
So you use Coble with all the money you do every day.
Also your insurances, your car, renting system, things like those run on maybe on mainframes,
maybe on PC, but on Coble.
So if we have this situation, it's an important thing.
It's obviously a bad thing that only proprietary products exist that can execute it because
you cannot reproduce it yourself, neither the big nor the slow ones.
And you can not easily learn it because, yeah, buy a license for some 1000 euros, that's
not really nice.
It also doesn't help to really develop the language.
And we have some proprietary environments.
Very special is IBM with its mainframe because in this case the Coble is very hard bundled
to the hardware and the hardware to the Coble.
So it's very fast.
And we have the PC system with actually a lot of environments, but nearly all were
brought by Micro Focus.
And Micro Focus now was bought itself two times, but that's a different question.
And there's Fujitsu.
And as you may see there aren't even any big European players in this.
So that's another reason that it's good to have free software because free software doesn't
have border and special regulations.
There are open source projects.
Previously there was OpenCoble.
This was now several years ago translated to a GNU project.
So we are actually GNU.
There's Open Source Coble.
They've also kind of forked from OpenCoble, made special for the Japan market.
And those were then later translated to Java.
So there's a Java option too.
There's a newcomer, this GCoble.
If you don't know there's GCC, Developer Room.
One talk will also be about that, how hard it is to pass Coble because Coble is so big.
And then another one is AutoKit.
It's a compiler to .NET.
It's very early in its stage.
So GNU Coble as I said was created long time ago, also long time before I get in.
It actually has roots in TinyCoble but was nearly rewritten to get OpenCoble.
We have two active branches, the one that is easily available for you all.
If you just do app install GNU Coble, jump, add, whatever.
So your normal package manager likely has GNU Coble available.
You just can install it with a glance.
That's the branch GNU Coble 3.
The shiny new thing will be GNU Coble 4.
So this would be building there self.
We have a bit of numbers but you can get it on your own.
So what's the benefit of GNU Coble?
GNU Coble does internally generate C code.
So the C code is quite portable.
You can run it on your Pi, you can run it on your main frame and everything below.
I of course have it on my mobile phone.
So no problem there.
The generated modules are really C89.
So you can run it everywhere.
The runtime library is C89 and uses some new features if they are available.
So on most systems you will have a current environment.
We pass the standard test.
There's a national standard test for it.
97%.
Actually, if you compare with the proprietary, they don't pass 97% but less.
We don't have support for object-orientated Coble.
That's a nice feature from Coble 22 which isn't used that much actually in the production
because you have the old code.
And messages.
This was a very old thing and now gets back in Coble 23.
There's a new messaging system which you can think of, MQ, Rabbit or things like that.
We have a lot of dialects.
And so Micro Focus has one or two.
IBM has its own and we have 19.
So it's relatively easily to transfer from one Coble to GNU Coble, three year Coble,
three year computing.
And for other code that is still missing, so we are not complete supporting all 19 dialects
of course.
But if there are projects, then we can just increase what is needed.
So the compiler also gets increased step by step.
And the ecosystem helps you with all the things that may wear on the mainframe.
Or otherwise if you just do SQL access, there's a standardised exec SQL thing that works in
C and that also works in Coble.
So Coble is still used a lot but GNU Coble also has many users already.
So actually if you think of GNU Coble, of course it's the new name of OpenCoble.
And OpenCoble was forked by Coble IT very early.
And for now I think that there are hundreds of big users of Coble IT.
So in some sense there are also users of GNU Coble.
We at Okamil Pro, we work with the French tax administration, the DGFIP.
And we add them to migrate from Gcos mainframes.
So Gcos is the name of a BUL mainframe that was created in the 80s.
And so they are moving from that dialect to GNU Coble on PC.
So we added the dialect for Gcos to GNU Coble for them.
And recently we had a mail on the GNU Coble bug mailing list from real time.
And they told us, okay, we have a bug.
We found a bug.
But we have been converting many and many programs from micro focus to GNU.
And we didn't find any other problem doing it.
So it's quite a nice result.
Maybe you want to talk about it.
Yeah, and actually I was contacted by someone, it's not on the list, but on the updated one.
That uses GNU Coble for his customers.
And that's a company for banking, so core banking, everything that you have in the banking,
apart from the online banking part, is part of the software.
And there are a lot of, there are some of those customers in the Dachie region that currently use GNU Coble.
And actually they migrated from Solaris and IAX or Plain Rel and Micro Focus
to GNU Coble on different environments.
And those, yeah, those have multiple, a lot of transactions each day where GNU Coble just works.
And they found actually that the GNU Coble environment is much faster than the original Micro Focus one.
What was part of the original introduction of this talk was how we reached this majority.
There's a lot of things on this paper, of course, but I think one of the biggest things is that it's got easier to work with
because people wrote documentation on it.
Other people helped with writing a pure Coble source code debugger using GCC.
There are a lot of approach actually that you can use for debugging Coble with GDB that way.
The tool sets around GNU Coble increased per demand so people can actually do what they normally do with the old compilers
or with the C compilers also on GNU Coble.
And many important things are also people using GNU Coble because you don't know if your compiler is complete if nobody uses it.
But if big companies use it for their software, you may or you'll likely find bugs.
And then you can fix them.
And this also helps because it's quite different if you have just some code, maybe even the NIST suite, which has a lot of code to run.
You don't see where the issue is, but if you run this with thousands of processes in parallel on a nice Linux machine,
then you see quite fast where the bottlenecks are.
So putting this into production helped a lot because this allowed us to tune for the actual issues on performance and also on memory.
So having a nice compiler is great, but you also need to have a good environment around it.
So we started working at OCaml Pro on a studio for Nucobol that we call Super Bowl.
So it's based on LSP, Language Server Protocol that we developed in OCaml for cobalt.
So there is a full cobalt parser in it.
And it gives you access to all the features that you enjoy in a modern editor.
So if you are interested in it, the link is getsuperbowl.com and there is a GitHub repository.
Actually, so it's not on the marketplace of VS Code for now.
It's still being heavily developed, but it can be tested directly from the project on GitHub.
So we have a screenshot.
It's not where you can see that you can go find references, for example, for some identifier.
You can find all the references.
So it's a small screenshot.
So as a conclusion, we wanted to show that Nucobol now is mature to be used in industrial settings,
where usually people use proprietary solutions.
It's nice because it's developed in Europe compared to the other solutions.
And you can use Super Bowl to develop with it, to have a modern environment.
And this year, there is a Google Summer of Code.
And there are projects on Nucobol.
So if you are a student and you want to contribute to Nucobol, it's a nice way to start.
So there is the URL here, but it's easy to find on the web page also, I think.
If you have any questions, please join us outside.
And we'll be happy to reply to all your questions.
Thank you.
Thanks.
Thank you.