
FreePascal and Lazarus Foundation - Tomte
http://lists.freepascal.org/fpc-pascal/2016-June/048215.html
======
JDuntemann
I loved Pascal instantly because my first language was mainframe APL, followed
by some weird in-house macroassembler that Xerox was using on its 8080-based
business boxes. Compared to APL, Pascal is not only elegant but transcendent.
Verbosity bothers me not at all (I used to write COBOL too) because I like
being able to read and understand what I've written six months after I set it
aside. You couldn't do that with APL, and I had a lot of trouble doing it with
C.

As a few other people here mentioned, I'm creating a FreePascal edition of my
ancient Turbo Pascal book, ripping out stuff that nobody needs anymore, like
CGA graphics and TurboVision. (I believe that there's a Turbo Vision clone
available for FreePascal, but I just can't force myself to learn it again and
write about it, even though I was writing paying apps with it in 1993.) The
book is free, and the current version (I tinker with it irregularly) can be
found here:

[http://www.copperwood.com/pub/FreePascalSquareOne--
08-06-201...](http://www.copperwood.com/pub/FreePascalSquareOne--
08-06-2014.pdf)

I'm going to stop building the release date into the filename with the next
release; just search for "FreePascal SquareOne.pdf".

I'm programming almost exclusively in Lazarus these days, a lot of it for the
Raspberry Pi. At some point I'd like to write a couple of shortish books on
specific Lazarus topics like databases, and once we get settled in Phoenix
I'll give it a try.

BTW, my friend erbo told me about this thread, so I figured I'd stop in and
say hi.

\--73--

Jeff Duntemann K7JPD

~~~
emmanueloga_
Are you updating your "Assembly Language Step By Step" book any time soon?

~~~
JDuntemann
It's about due, but until the publisher decides to update it, I don't get to
update it. There are length issues: I'd like to spend another 100 pages
covering 64-bit issues, but there's a hard limit of 600 pages on the book. I'd
have to cut something else out, and that's a hard decision. When I get the
call, I will definitely do an update, but when that happens, again, is not up
to me.

------
mtkd
So much unnecessary negativity on Pascal

Much of what exists in contemporary dev tools can trace some DNA back to Turbo
Pascal and Delphi 1.0

Anders Hejlsberg is a footnote in the story of a few tools - but was as
instrumental as DHH in changing perception of how software could be developed,
how the tools look/feel and how objects are interacted with at design time

I see a lot of current work on the DOM, I see a lot of companies wanting
portable desktop apps and looking at the DOM as the platform for that, then I
look at what Anders did in early 90s and think there is so much that can be
applied to current problems

~~~
nickpsecurity
You might have liked the Juice project:

[http://www.modulaware.com/mdlt69.htm](http://www.modulaware.com/mdlt69.htm)

Just found a Github page while looking for it where they might have put up the
old source:

[https://github.com/Spirit-of-Oberon/Juice](https://github.com/Spirit-of-
Oberon/Juice)

------
zoom6628
Learn Pascal on an Osborne-1. First project was a device driver - a classroom
project no less! Having coded in lots of languages since then, I like Pascal
for its structure, its rigour, and uncomplicated binaries and installation. I
dont mind if IDE setup is hard as long as anything i build is easily shared
with others. Was easier and faster to get Lazarus working on my Mac than
Visual Studio 2015 on my Windows (T440p) laptop! FPK/Delphi hands down winner
- the only thing easier to share is probably DOS batch scripts.

Recently look at some Go code and thought it looked like simplified pascal.
LOL. Agree with the other posters that pascal wasnt ever 'cool' because when
it was being used for cool-stuff like writing MacOS it wasnt widely
publicised, and unfortunately it was used as a learning language (and lets
face it not many of us remember school as being uber-cool!).

There are precious few languages that can be used for learning and for getting
real work done - but if you look at those, they have been around for a long
time: Fortran, COBOL, C, Pascal, Lisp.

On another note i look at the code, and platforms, and I think that Pascal has
an opportunity to be used in IoT applications. Small footprint objects are
well suited to constrained environments like my own projects (Arduino, Pi,
CHiP, Xbee) where one also needs a compiler that helps to keep the world safe
from my bad code (like strict types and pointer bounds!).

The folks working on FPK and with Lazarus have done a superb job. Great tools,
amazing cross platform support, and delivering stuff that helps get things
done.

~~~
zoom6628
I forgot mention Python as a learning langage that is also widely used for
getting stuff done. Of all the languages i mentioned it is cool. Ive been
using it since 2001 - about the same time as i last used Delphi for work.

------
claystu
So, I downloaded the latest version to OSX. Effortless install. Opened Lazarus
and it looks great. Threw a few gui components onto the blank form and hit
compile. The program compiled almost instantly, popping up a native gui that
looks great.

Excitedly went to click on documentation to learn more and...there is no
documentation! Instead, there is a sort of slush pile wiki that, at best,
might be considered an unorganized outline for documentation, but that's all.
In 2016, that wiki doesn't cut it.

To the Lazarus developers: Lazarus looks awesome. Technically, it appears very
mature, but without solid, deep, well-organized documentation how do you
expect anyone to learn how use it?

~~~
gnud
Inside Lazarus, go to the 'help' menu and select 'help'. There's quite a lot
of documentation!

There's also context sensitive help. Put the text cursor over a type name,
like 'TForm' in the default code that's there when you start Lazarus. Press F1
to see the documentation for that type.

~~~
claystu
I just checked. Help shows documentation on FreePascal and what the different
options are for Lazarus as an IDE, but I don't see any more documentation on
how the GUI system works, which is supposed to be what makes this system so
special in the first place.

~~~
vram22
>but I don't see any more documentation on how the GUI system works

What exactly do you mean by that? At a shallow level, it should be fairly
obvious - it would be like any other event-driven GUI development environment
- create and place widgets on a window, set their properties, write routines
that respond to (keyboard and mouse) events, build and start the app, the
event loop takes over, your routines get triggered by events and do stuff,
etc. Are you looking for more depth, maybe on the internals? Asking out of
interest in the question and answer myself.

But I'm not sure you need a lot of that depth to start using it. Just looking
at some basic code examples, and using the online help as a nearby comment
said, should give enough information on Free Pascal and Lazarus widgets, their
inheritance hierarchy, their properties and events to which you can respond,
etc. I know this because I have followed such an approach in other GUI
environments, e.g. wxPython, after learning the basics of event-driven GUI
programming, from my first such GUI env, and managed to get some work done.

~~~
claystu
I mean docs that assume I've never looked at any other GUI system and don't
know what an event even is, much less how to register one.

What if I'm a first-time programmer or have only ever programmed in MIT
Scratch? What if I'm a PHP programmer? Do the Lazarus components work like
Swing? Do you register event handling the same way?

I want tons of examples for every component--examples that start simple and
work up in terms of complexity with comprehensive explanation along the way
and I want it all linked under "Documentation" off the front page.

Now that's a lot. I recognize that. But I don't care. There are whole books
available for Swing, JavaFX, Windows Forms, and WPF, not to mention Web
Design. That's the standard today. Book scale documentation...

I'll say it again: I'd like to use Lazarus. I spent the morning programming a
desktop application that could have been done in Lazarus, but it wasn't
because I'd rather build programs than decipher an undocumented system, and I
suspect I'm not alone.

~~~
vram22
>I mean docs that assume I've never looked at any other GUI system and don't
know what an event even is, much less how to register one.

Got it now. From your initial comment in the thread (you used words like
'Threw a few gui components onto the blank form and hit compile.', I thought
that you were a programmer with knowledge of at least the basic concepts and
some practical experience of GUI development in at least some other GUI dev
env. And my answer was based on that assumption. I now see that, whether you
are an experienced programmer or not, you are looking for docs that start from
the beginner level and are very comprehensive.

I have to say I sympathize with that viewpoint. It would be great if all
software products were documented as well as that. However, going by real-life
experience, I am not sure that many are.

>What if I'm a first-time programmer or have only ever programmed in MIT
Scratch? What if I'm a PHP programmer? Do the Lazarus components work like
Swing? Do you register event handling the same way?

Got it. But see my answer to your next point below.

>I want tons of examples for every component--examples that start simple and
work up in terms of complexity with comprehensive explanation along the way
and I want it all linked under "Documentation" off the front page. Now that's
a lot. I recognize that. But I don't care. There are whole books available for
Swing, JavaFX, Windows Forms, and WPF, not to mention Web Design. That's the
standard today. Book scale documentation...

Yes, there are books - and there were, years ago too, for earlier products of
those times. (In fact, see my other comment in this thread, in reply to
teraflop's comment about door-stoppers -
[https://news.ycombinator.com/item?id=12045536](https://news.ycombinator.com/item?id=12045536)
:) Again, though, going by my own experience, there are not many software
products that have that level of documentation in the product or online help.
(Microsoft MSDN and Borland earlier come to mind as some that did.) I am not
saying this is a good thing. As you say, I've also found, that one often has
to resort to books on the subject of that software (if they are available -
since they are not available for some less popular subjects). I've learned
many different software technologies that way - via in-depth books on the
subject, that I bought, or borrowed from company libraries.

>I'll say it again: I'd like to use Lazarus. I spent the morning programming a
desktop application that could have been done in Lazarus, but it wasn't
because I'd rather build programs than decipher an undocumented system, and I
suspect I'm not alone.

Out of interest, what technology did you program it in?

No, you're definitely not alone.

However, in the kind of doc scenario that you describe (e.g. for Lazarus),
there are still ways, though somewhat less efficient, of getting the learning
and work done. Like this: read what docs are available (thoroughly, over
time), read the sample programs, run them (correlating the code with the docs
available for the code in the sample), step through them in a debugger to see
what happens to program state (i.e. variables) internally as the program runs,
read a lot of posts on the mailing list for the software, ask relevant
questions on the mailing list as needed, to help you learn, share your own
learnings on the same list, google for other online info on the topic, such as
blogs, free online tutorials, etc. etc. A lot of people, me included, have
learned those techniques over time and use them to overcome somewhat the
disadvantages of less than perfect documentation. I realize that you may know
all this already, but thought of posting it for the benefit of some readers
who might not. As a trainer, I often find that beginners are not aware of many
of these learning techniques - which are pretty effective, over some time. The
main thing many of them know is how to use Google and StackOverflow, and if
they don't find the answer there (and quickly), some of them give up overly
soon (and thereby not meet their goal).

HTH.

Edit: grammar and typos.

~~~
claystu
You're right...it's still doable. I could if I wanted, but the cost/benefit
analysis of my time vs the payoff of using Lazarus just doesn't make it worth
the time.

Interestingly, here's a new link on HackerNews for the new haskell website:
[https://haskell-lang.org/](https://haskell-lang.org/)

Now that's what I'm talking about...

~~~
vram22
>I could if I wanted, but the cost/benefit analysis of my time vs the payoff
of using Lazarus just doesn't make it worth the time.

I guess that partly depends on how much work you plan to do with it, the
expected benefits of that work, a few other factors, and also partly it is
"each to their own".

Anyway, good luck, whatever tech you use ...

Will check out the new Haskell site, thanks.

------
boznz
" there are still many things need to be fixed and enhanced on both projects"

I can think of a couple of minor improvements, but overall for Windows and
Linux desktop and database development in Lazarus (which is all I do) I have
not really seen anything that needs much in the way of fixing and the code it
is producing is pretty efficient and has been in my clients production systems
for over 12 months now.

Keep up the great work chaps :-)

------
mythz
Mad props for all the different OS's and UI toolkit's that their Lazarus IDE
runs under:

[http://wiki.lazarus.freepascal.org/Screenshots](http://wiki.lazarus.freepascal.org/Screenshots)

Rare to see a Native UI targeting so many platforms.

~~~
ivoras
Believe it or not, Lazarus is probably the single most-cross-platform-
compatible GUI builder for native apps that exists, anywhere.

Neither Java, nor Qt nor anything else come even close. And the apps are
native!

As for the "I don't like Pascal because Pascal is ugly" crowd: it's only
different, and it's almost by chance (i.e. reasons external to the language
itself) that most of today's production languages have used C for their syntax
template; if they've used Pascal, then the C syntax would be the "ugly" one.

Microsoft has basically poached developers working on Delphi to develop the
first versions of C# and it showed both in the design of the language
(properties, the type system) and the early IDE.

~~~
hugh4life
"Believe it or not, Lazarus is probably the single most-cross-platform-
compatible GUI builder for native apps that exists, anywhere."

Except they build on GTK 2, Qt 4, and Carbon on OSX. I haven't used it, but
the whole LCL architecture seems absurd to me as there's no way that a project
like theirs can keep things up to date.

[https://upload.wikimedia.org/wikipedia/commons/6/65/LCLArchi...](https://upload.wikimedia.org/wikipedia/commons/6/65/LCLArchitecture.png)

~~~
leledumbo
It's been 15 years since Lazarus (and thus LCL) was born and the following
changes has happened:

\- GTK1 interface is obsolete (was mainstream), GTK2 is mainstream, GTK3 is on
the write \- QT4 is mainstream, QT5 is on the write \- Carbon is mainstream,
Cocoa is near completion

I believe legacy already shows how the project can keep things up to date.
It's the power of full community driven project, there's no necessity for a
single maintainer to update everything on his own. Contributors may come and
go, but they're there to update things.

------
dmix
I wish they chose a better name than "Free Pascal". It makes it sound like a
lower-quality version.

After that recent Object Pascal guide was on HN [1] I've been meaning to try
the language out. It looks like it might be a nice alternative to using Ruby
on some small side projects where I need a quick OO language to work with.

I've grown attached to static types so it looks like it might be a good
option. My only concern is whether the tooling has been modernized or not.

[1]
[https://news.ycombinator.com/item?id=12027008](https://news.ycombinator.com/item?id=12027008)

~~~
ics
You might also be interested in Nim, see for example:
[http://goran.krampe.se/2014/10/29/nim-and-
oo/](http://goran.krampe.se/2014/10/29/nim-and-oo/)

(Static types, basic OO, syntax, fast compilation)

~~~
dmix
Thanks for the heads up. Will do.

------
baq
modern pascal is actually pretty good. it's very unfortunate that it isn't
considered sexy. i learned programming on turbo pascal and used to think that
pascal isn't a serious language. years later, after seeing that it's not dead
and dropping prejudices against it i can see that it lost pretty much only
because of its perceived uncoolness.

~~~
trentmb
Or that you have to drop $1,405.00 [0] to get a 'professional' environment.

[0] [https://www.embarcadero.com/app-development-tools-
store/delp...](https://www.embarcadero.com/app-development-tools-store/delphi)

~~~
Animats
That's the problem. You can't sell programming tools any more. Everyone
expects them to be free. Walter Bright, the designer of D and one of the first
good C++, is on here, and has mentioned that before.

So programming tools come from some source that has an agenda. Oracle.
Microsoft. Google. Even Mozilla.

~~~
trentmb
I don't mind paying for my tools. I have a ST2 license, and will be buying an
ST3 upgrade license when it's time.

It's just that $1.5k is hard to justify for a single language
environment/compiler. VS2015 Pro is $499, while a yearly Pro/MSDN
subscriptions is $1,199/year.

~~~
dwc
That depends. As long as I've been in the game there have been relatively
expensive options. Back in the day I kept hearing about SmallTalk and I saw
the price tag in an ad in Dr.Dobbs. Sticker shock! But "serious" pricing is
still alive today. Check
[http://www.lispworks.com/buy/prices-1c.html](http://www.lispworks.com/buy/prices-1c.html)
for instance.

For some languages, lower prices won't significantly increases sales volume.
And 1.5K is not a barrier if it's your bread and butter language. It's in the
same ballpark as a developer machine.

~~~
jestar_jokin
The problem is, to gain traction these days, you target the developers, give
them enough resources to work on something in their spare time, and hope they
have enough influence to make their company switch from language A to language
B.

Charging the developer, before they even have a chance to try the language
out, when there are other free options available, means they'll never even
give the language a chance.

~~~
dwc
I agree with you, but I also still agree with me:

Making Delphi or Common Lisp the next hotness is pretty much a lost cause, and
has been for a long time. The people using those things tend to be heavily
invested in them, and still making money. If you're not making enough money to
spend US1.5K on your primary tool then you're not really making money.

Most of the people who balk at $1,500 will probably _still_ pick the free
option rather than pay $19.99.

Even though there are good free options (in the case of common lisp there are
multiple good free options), there's still no gaining of traction.

So these companies charging money have defined their target market as people
already using the language professionally, and they've found a price point
that lets them stay in business and provide quality tooling (specialized IDEs,
debuggers, GUI frameworks, et al). If they lowered their prices to $19.99,
rather than attract loads of new mindshare they'd simply go out of business.

------
analognoise
I'll donate when it all gets setup. I really like Pascal. Jeff Duntemann is
writing new intro books and releasing then under a Creative Commons license
iirc. It's a great language and a killer environment.

~~~
vram22
>Jeff Duntemann is writing new intro books and releasing then under a Creative
Commons license iirc.

I remember his name as a computer book author from older PC days and
mags/books, but have forgotten what he used to write about. Did he write about
C or Pascal, say Turbo Pascal, earlier too? Just saw his site
([http://www.duntemann.com/](http://www.duntemann.com/)) and it seems to show
only assembly language books (on a quick look). Not that it matters, of course
he could write books on Pascal now, but just wondering whethere he wrote any
Pascal books before.

>It's a great language and a killer environment.

Agreed. Was a Turbo Pascal user for some years, great language and lightning
fast dev env. Done smaller amounts of Delphi work too, and loved it. Too bad
about the corp. issues that have happened, and about no current low-cost
edition. They discontinued Turbo Delphi Explorer, or rather the Turbo Explorer
series (existed in around 2006) which included Turbo C++ Explorer too, IIRC.
And the TD Explorer at the time was available in two versions, for Win 32 and
.NET.

~~~
erbo
I posted a link to the Foundation's Web site to Jeff's Facebook page. (He's
been busy getting his house in Colorado Springs ready to sell, as he and his
wife are moving to Phoenix for health reasons. Facebook is about all he has
time to check these days.) I'll also link this HN comment thread to him.

Jeff's blog is at
[http://www.contrapositivediary.com/](http://www.contrapositivediary.com/) ,
and he updates that more frequently than his main Web site. (Which is to say,
pretty infrequently at the moment, though I expect that to change once his big
move is over.)

~~~
vram22
Thanks, will check his blog.

------
Clubber
This is from my personal experience, YMMV.

Programs written in Turbo C ran faster than programs written in Turbo Pascal,
that's why it lost in the MSDOS world.

As an example, WWIV was a very popular BBS in the 80s and early 90s that
included source code, so it was popular with a large group of hobbyists. It
was originally written in Turbo Pascal but when converted to Turbo C and ran
noticeably faster. Other BBSes (Telegard) took WWIV code (allegedly) written
in Pascal for their software and they ran slower than the Turbo C version of
WWIV. We're talking about 286 4/10Mhz machines with a turbo button, so the
difference was noticable. The idea that Turbo C was faster than Turbo Pascal
is probably why Pascal lost the MSDOS wars.

Visual Basic was marketed better than Delphi, that's why it lost the Windows
wars. Delphi was _way_ ahead of it's time. The VCL (the Delphi library) was
robust and modern for the TCP/IP stack. There were components for everything.
They released a Linux version called Kylix started in the late 90s. Delphi had
many features and compiled to machine code, so it was technically superior to
VB. It was much faster to develop with than Visual C++ also. Borland got some
executives that made some poor branding decisions, like renaming the company
to Inprise (??) then naming it back. Once C# gained traction, Delphi slid into
obscurity and was purchased by Embarcado. It mainly exists as a tax on
companies who haven't migrated to a more common language.

I learned Turbo Pascal and Turbo C in middle school by tinkering with BBS
code. I was taught CS in High School using Turbo Pascal and again in college.
It was a great little language that runs very fast machine code, and served me
well. It is very capable for production environments, but I prefer C syntax
now a days though. If Pascal prompts a return from web to native, I'd embrace
it. Web is significantly more tedious than the RAD tools for native
applications it replaced for front end development.

Interesting aside, Object Pascal conventions state you should prefix class
names with a T (for Type I think). So if are rummaging through an API and you
see a lot of types that start with T, you know it was written in a Pascal.

~~~
e12e
One of the optimization goals for the design of Pascal was compile speed -
single pass compilation source > link > binary. That usually also meant less
optimizations. On the other hand, Turbo Pascal was really popular as glue code
for programs and demos written predominately in assembler for speed... so
there's that.

I wonder if a rewrite of WWIV from Pascal to Pascal would've yielded similar
speedups, or if it really just was the optimization passes that made all the
difference. If so, one might think that a Pascal compiler that targeted C
might have been an (almost) as good solution at the time.

~~~
Clubber
Great points about the compile speed, I had forgotten. Also, Delphi / Pascal
used no header files, which was wonderful.

I think 20 years ago, Delphi (Pascal) was far superior to Visual C++. It
didn't run noticeably slower but had all the RAD tools for fast development
time that VC++ lacked. Too bad Microsoft's juggernaut defeated it with VB.

WWIV could have been improved algorithmically between the Pascal and C++
versions, certainly. Also, the fact that the processors of the day were so
slow, the difference today would hardly be noticeable unless you ran thousands
of iterations and timed them in the code.

------
e12e
There are some interesting replies in that thread, eg:

[http://lists.freepascal.org/fpc-
pascal/2016-June/048216.html](http://lists.freepascal.org/fpc-
pascal/2016-June/048216.html)

[http://lists.freepascal.org/fpc-
pascal/2016-June/048217.html](http://lists.freepascal.org/fpc-
pascal/2016-June/048217.html)

------
lllorddino
I tried out Pascal a while ago and really liked the language. Also installed
Lazarus and was able to make a simple Windows GUI. Although now I'm on Linux
and may have to give it another go.

------
supernintendo
I wonder how prevalent Pascal is in 2016. I've been meaning to write some on a
classic Mac OS system I have laying around (just for shits and giggles).

~~~
int_19h
Delphi was very common for LOB applications in some European and ex-USSR
countries in 90s and early 00s (more so than VB, which, I think, filled the
same niche in US). Plenty of those are still running in production. So, while
I doubt there's a lot of new code being written in it, there should be quite a
few jobs maintaining and extending an existing codebase.

------
systems
is this new

~~~
trentmb
_Mon Jun 27 08:14:36 CEST 2016_

~~~
kazinator
That's just the date on someone's excited post to a mailing list, at having
discovered
[http://foundation.freepascal.org](http://foundation.freepascal.org).

I don't see any explicit dates in that site's content. Oh, except that the
projects have dates on them. Both current and past projects are tagged 2016.
Busy beavers! Mid 2016, and already three 2016-dated items are "past
projects".

~~~
bencoder
next message in thread is saying that it hasn't been announced yet:
[http://lists.freepascal.org/fpc-
pascal/2016-June/048216.html](http://lists.freepascal.org/fpc-
pascal/2016-June/048216.html)

