Any programming language needs a forum...

It's the first question anybody asks, secretly, so I'll answer once, publicly,

Although Open Euphoria version 4.x is based on Robert Craig's work - it's NOT Rob's work.

Open Euphoria group could only improve the Euphoria programming language under the leadership of Robert Craig and his vision. Yet their pride and blindness leaded them to bang their heads against the wall.

Row, row, row your boat
Gently Down the stream.
Merrily, merrily, merrily, merrily,
Life is but a dream...

Row, row, row your boat
Gently Down the stream.
If you see a crocodile
Don't forget to scream...

Chorus:
If you see a crocodile
Don't forget to scream...

Tags:
OpenEuphoria

Yes.
A professional C/C++ programmer can do it. According to Rob - it is fairly straightforward.

I want to say another thing:

Most of you probably don't know that a 8-bit CPU is able to process 32-bit, 64-bit, 128-bit, or even 1024-bit numbers - easily. And efficiently.

Yet, once you design a 8-bit CPU that will process 1024-bit numbers (which is no big deal) - the tech giants will lose their money.

So they put us in a race for "new" hardware, "new" software and "new" technology forever, for the sole purpose of making money. Although 8-bit CPU is the right way to go. Any other component in the computer's world is based on streams of 8-bit values (including Hard Drives, RAM Memory, Internet, Cellphones - Everything). The only exception is the CPU.

A 8-bit CPU which is able to process a stream of 8-bit values is the most natural and the right way to design a CPU - just like any other computer related component or protocol.

The bottom line: personally I will continue to use Euphoria 3.1.1 even inside an emulator if necessary (as I do with 16-bit applications), I will keep my sanity - and leave the insanity. Leave the race for money by multi-trillions tech giants.

Goodby lies. 8-Bit CPU can do (and should do) the job much better then 32-bit/64-bit or 128-bit CPU.

I will continue to use Euphoria 32-bit which is able to calculate precise integers of 50 (actually 51) bits. Do you really need more then 50-bit integer? It is a huge number: 1,125,899,906,842,623 - do you need more then this? Not really. Yet if you do, then a software library for big-numbers can do it for you (this is how Python language works, as far as I remember, and this how other programming languages worked with 8-bit and 16-bit CPUs).

Big numbers were already processed by CPUs in the 60s I guess, yet now, in 2020, it is considered to be a problem? Let me out of this madness please.

And about the limitation of file size: currently Euphoria 3.1.1 supports file size up to 2GB, also on DOS system. Do you need more then this? If you do, then change the logic of your application, i.e. create a new database for each year or each month - simply put: grow up.

Tags:
64-bit

Some are "complaining" that there is no string type in Euphoria. Well, Euphoria does not need it at all.

Yet since all I/O (Input/Output) operations in programming must be done with the string type, Euphoria 3.1.1 and Lib2 are providing all you need for manipulating strings easily, the traditional way.

Behind the scenes, it's a different story - as I said before, in Euphoria there is no "traditional" string type, only sequence type, which is a way more powerful concept.

BTW, remember that "string-sequence" in Euphoria is made of 31-bit integers, not with 8-bit integers, which means that strings in Euphoria are by default Unicode strings rather than ASCII strings - yet, why should you care?

Here is a short example code, with only few traditional "string" functions, to calm the storm...:

 
include machine2.e -- string() type, from Lib2 version 1.41
 
constant SCREEN = 1, EOL = '\n'  -- EOL is End Of Line character(s)
 
string name, website   -- declare two variables of string-sequence type
 
name = "shian lee"
website = "http://www.RapidEuphoria311.com/"
 
puts(SCREEN, name & ' ' & website & EOL)
    -- prints "shian lee http://www.RapidEuphoria311.com/"
 
 
include string.e -- basic string functions, from Lib2 version 1.41
 
string both -- declare one variable of string-sequence type
 
both = name & website
 
puts(SCREEN, both & EOL)
    -- prints "shian leehttp://www.RapidEuphoria311.com/"
 
puts(SCREEN, left(both, length(name)) & EOL) 
    -- prints "shian lee"
 
puts(SCREEN, right(both, length(website)) & EOL)
    -- prints "http://www.RapidEuphoria311.com/"
 
puts(SCREEN, right_of(both, ".", 0) & EOL)
    -- prints "com/"
 
puts(SCREEN, mid(website, 5, 12) & EOL)
    -- prints "Rapid"
 
puts(SCREEN, change(website, "", 3, 25) & EOL)
    -- prints "http://www.RapidEuphoria.com/"
 
puts(SCREEN, change(website, 's', 0, 5) & EOL)
    -- prints "https://www.RapidEuphoria311.com/"
 

Tags:
string

Thanks God for that!!!

OOP (Object Oriented Programming) is not a modern concept, it is a very old concept, wrong and delusional.

The "flagship" of OOP was and is ENCAPSULATION. WOW! What a term! Scary.

"Encapsulation" exists from the day procedural programming, such as the C language, started to use subroutines and modules (files). "Encapsulation" was not invented by OOP freaks (as some may argue).

The next "flagship" of OOP was and is HIERARCHY. Jesus. OOP became a religious order. That's scary.

"Hierarchy" is a failed logic. Once you implement it - no more freedom. Since each "object" MUST BELONG to another object, and you cannot "lend" or "borrow" to/from someone's else private object - even if you really need it. What a stupid and failed concept. Yet decades ago, some enthusiastic freaks thought that it's really cool.

OOP HIERARCHY = Losing you freedom as a programmer. There are no limitations in procedural programming (such as in C, Basic, or Euphoria 3 programming languages).

At the end of the day, anything significant is written with procedural languages, especially C.
UNIX/BSD/Mac OSX(BSD)/Linux/Now even Windows-10 (probably) are written in C.
Popular and great GUIs (Graphical User Interfaces), such as GTK, are written in C.
Let me remind you, C is a procedural programming language without any OOP support, just like Euphoria 3.

Let me remind you that any successful programming language, such as Python, Java, Basic, etc is written using procedural programming language or Assembly - OOP is simply too clumsy (to say the least) to do the job. (And I did not verify it with Wikisomething).

Well well, decades ago, few enthusiastic freaks had a "great" idea called OOP. I'm used to such people, I see them everywhere, also today.

Sorry for bashing OOP, yet some experienced OOP programmers already admitted that OOP was a mistake from the very first day, decades ago. And they understand the OOP concept very well, and they are completely right.

My conclusion: procedural programming languages, such as C or Euphoria 3, gives you the freedom you need as a programmer to do things your way, the correct way. Euphoria 3 in particular is far more powerful then OOP languages, conceptually.

So stop talking about OOP - it does not deliver the "magics" that it promised. It is a failed concept, yet popular, just like Coca cola. Nothing else.

I could elaborate much more, but what for. The King is Naked (from "The Emperor's New Clothes").

Tags:
OOP, Object Oriented Programming

Euphoria 3 is a very high level language, it does not use low level tricks, it lets you program safely, without worrying about low level issues.

Yet Euphoria 3 allows you to perform low level operations when needed (when you want to access C shared library - .DLL/.so, DOS interrupt, i386 machine language, or just for extremely fast code).

In Lib2 library I'm using low level functions for manipulating bits, such as and_bits(), or_bits(), etc, since a library routine must be fast and efficient as possible. A library routine is a basic building block which should be suitable for many uses.

In your program you are not forced to use low level functions. Euphoria 3 offers high level functions for manipulating bits safely (shift bits, rotate bits, slice bits, etc), these functions are: int_to_bits(), bits_to_int().

Although these are high level bit manipulation functions, they are extremely convenient, very safe, and... very fast, since in Euphoria 3 integer calculations are very fast. I recommend you to use these functions (unless you need some extremely fast operations from Lib2 library). I personally used these functions a lot, that's why I can recommend them.

Conclusion: In Euphoria 3 you can use high level functions for manipulating low level bits, using the functions int_to_bits(), bits_to_int() and also bytes_to_int() and int_to_bytes(). See "Operations on sequences" in the Reference Manual (refman.doc).

Tags:
bit, bits

Well Euphoria 3.1.1 never became a commercial product, and never had a multi-billion sponsor - OK? That's why Robert Craig could not afford spending time on an advanced cross-platform GUI library, etc.

I assume that nobody wanted to sponsor Euphoria 3 since it would make other languages useless, i.e. languages such as BASIC, VisualBASIC, Python, Ruby, PHP, etc could become useless if Euphoria 3 would have take their place. Sincerely. Honestly. Truthfully.

There are some great open source cross-platform GUI libraries, written in C, you just need to look for them and wrap them into an Euphoria 3 file.
I recommend you to first wrap the most elementary functions, such as text-box and check-box, and give it a version number 1.0.0; Only then, slowly but surely, continue to wrap the more advanced objects. You don't need to wrap the entire GUI library - much of it is for nerds.

Lib2 provides a lot of elementary and useful functions + text mode simple IDE: edu. Using Lib2 can save you lots of time. The edu IDE supports context sensitive help for all functions - so benefit from it.

And last: if you are a disciplined programmer, you may add a practical module for Lib2, such as a "big numbers" library or a "complex numbers" library. If your code is standard, documented (as in Lib2), debugged, clear and clean - I will be more then happy to add it to Lib2. Anyway, creating additional libraries can be done by YOU. No need to wait for someone else to do it. If you're good at Math (I'm not), Trigonometry, Statistics, Graphics, whatever, then simply contribute your talent and knowledge, 알겠느냐?

Tags:
library, libraries

Is seems to me that some people missed the point.

An error handler can be used in the following cases:

• 1. Your program have a logical bug (division by zero, index out of bound, etc).
  
• 2. You wanna make your life easier (if file's format is wrong then just ignore it, etc).
  
• 3. You wanna load a plugin that may have a bug.
  
• 4. You don't know what you want.

I'll answer the above:

• 1. If your program have a logical bug - some data, somewhere, may be corrupt. What can an error handler do about it? Nothing. You should fix your bug.
  
• 2. Instead of displaying a message "Illegal function call" whenever a single comma is missing... just create a decent function to deal with it.
  
• 3. A plugin is a program, just like your program. If a plugin has a bug then it should be fixed - till then: don't use it. The sky won't fall.
  
• 4. That's the common case. Take a break.

Euphoria 3 crashes on logical bugs, as it should. But it allows you to call a crash_routine() to cleanup the mess before your program stops, or to simply initialize and restart your program.

In any case all files are closed automatically before your program crashes.

When your program crashes a file is created in the current directory, "ex.err", with detailed, readable information about the crash: values of variables, routines that leaded to this crash, and the exact location of the crash (file, line, column). The crash routine is versatile and you can use it the way you need.

To deal with very specific operating system's errors, you can create an error handler yourself (as I did in DFS library for the infamous DOS Critical Error Handler). Yet these are rare cases.

If you need more then this then you better learn programming.

BTW, Euphoria 3 is not BASIC. BASIC crashes on other bugs beside logical bugs, therefore in BASIC you must have an error handler... go figure: they created the problem - then offered the solution. Profound, indeed.

Last: many complex programming methods are leading to lots of unnecessary bugs, which makes an error handler a "life saver" - just avoid those "modern" methods, keep it simple, you're writing a program - not creating another Frankenstein.

Tags:
error, error handler

Simple:

Multitasking is built into the Euphoria 3 programming language.

The following code is Task #1 by default:

puts(1, "Hello World!\n")

You can add to your program as many tasks as you need and define how you want them to behave.

Multitasking in Euphoria 3 is very simple to implement and totally safe, since it is a builtin software attribute, rather than hardware's multi-threading.

If you need the speed of Multithreading, just remember that computers do not get faster! i.e. although the hardware is getting faster - the software is far more bloated. The result is that a multi-core 64-bit CPU with a modern operating system works just as fast as MS-DOS on an old 386 machine.

Give yourself a break and enjoy the builtin simplicity and safety of Euphoria's Multitasking.

See also euphoria/doc/tasking.doc for details.

Tags:
Concurrent computing, Multitasking, Multithreading

Euphoria 3 provides far more flexible database system then a SQL (Structured Query Language) database; It is called Euphoria Database System (EDS).

EDS is also a relational database but does not have a special tedious language such as SQL to control it, and most important: you can store any object as data (or even key), which means that you can change the record's structure at any time, add fields, delete fields, whatever - records are completely flexible, nothing is fixed.
No more worries (did I forget something? is it the correct data type? do I need to add an extra column, just in case? is the record too long, not efficient, should I change it now? how will I change it in the future?, etc).

In many database systems you must define each field in the record very carefully - not in EDS. In EDS you're free to make critical decisions later. (This is typical to programming with Euphoria 3 in general).

See also euphoria/doc/database.doc

Lib2 version 1.41 provides also traditional functions for direct access (Random access) database, if you need. Direct access database has fixed record's structure but it is the most efficient and fast way to retrieve and store data in a file.

Of course - there are many ways to create a simple database file, in text or binary format, using the print() & get() routines, or in many other creative ways, such as simple CSV (Comma Separated Values) text file, using functions from string.e library (Lib2) - and... the sky is the limit.

Conclusion: creating a database in Euphoria 3 is very simple.

Tags:
Database

Euphoria 3 has only 4 data types:

The main data types (variable type) are:

• atom - any number.
  
• sequence - any sequence of numbers and/or (sub)sequences.

The helpers data types are:

• integer - a limited atom (yet still an atom), but extremely fast.
  
• object - any of the above (integer, atom, sequence).

OK, so briefly, what's the big deal?

• Data types are the biggest headache in any programming language - NOT in Euphoria 3.
  
  
• sequence is the most important data type in Euphoria 3. Any complex data type in other languages can be represented by it (including OOP).
  
  
• Data types simplicity in Euphoria 3 allows you to focus on your project - not on the programming language itself.
  
  
• The object type is useful since Euphoria 3 code is generic by nature. Many library routines accept an object as an argument.
  Team's work can be done safely by passing a single object argument to routines; it allows backward compatibility with older versions of these routines, i.e. you only need to update the routine itself - not the entire project.
  
  
• The bottom line is: computers understand only numbers. A flexible sequence of numbers is all you need for your program.

Additionally, the simple type() mechanism in Euphoria 3 makes it a very safe language, where you can define your own types easily. What else do you need?

Epilogue:

Look at the C/C++ languages: how much time you must spend on data types? no further comment.

Look at BASIC: choosing the right data type is your daily bread.

Look at Java: the definition of data type is beyond comprehension; for nerds only.

Look at Python: no need to declare data types at all; not recommend in Boeing 747.

Tags:
type, data type, variable

Should I really explain again?

Evil world is based on evil money. (is this enough? no).

Young people choosing programming language according to Job offers and salary.
The marketing sites repeating their mantra:

• JavaScript
  
• HTML/CSS
  
• Java
  
• C++
  
• Python
  
• PHP
  
• C

Each year it's the same story, only the order's changing.

People are obsessed with Internet and Smartphones, they wanna make big money! JavaScript and Java is the key! Programming became less important. Programming as an art - even less.

The fact that Euphoria 3 is not officially developed anymore - just shows how much brainwashing is the main priority of the tech giants.

Epilogue:

• If you wanna make big money - be a stripper. It's much faster then programming.
  
• Working for tech giant doesn't mean that you're a good programmer (to say the least).
  
• Weak people cannot think and analyze the truth - they rely on other's opinion.
  
• The King is Naked. Languages like Java are great success in terms of brainwashing.

Tags:
Euphoria 3

Euphoria version 3:

• Has an overall and well defined strategy by Robert Craig.
  
  
• Has a very professional and correct behavior, exactly what you would expect.
  
  
• All aspects of the language are polished and synchronized. Nothing is unrelated or indefinite.
  
  
• Extremely simple, readable, maintainable and logically-correct language.
  
  
• Powerful and rapid language without stupid elements.
  
  
• Very High Level language. No need to worry about low level issues.
  
  
• Minimalist language. Hence, Readable & Maintainable. Only what you really need for programming.
  
  
• No "Dead End". The language is extensible through libraries.
  
  
• Supports the main platforms: DOS, Windows, Linux, FreeBSD. Easy to write generic code that works on all platforms.
  
  
• A 32-bit language. On DOS as well.
  
  
• The data types issue is not exist in Euphoria 3. (The worst nightmare in other languages).
  
  
• The source code of Euphoria 3 is written in C and in Euphoria 3. Easy to compile for other platforms.
  
  
• Can use and create shared C libraries.
  
  
• Interpreted language (with all the benefits that comes with it).
  
  
• Allows you to create standalone executable files, shrouded files or translated files.
  
  
• Suitable design for team's work.
  
  
• Very easy to create CGI (Common Gateway Interface) applications.
  
  
• Very safe language. Programming with confidence.
  
  
• Extremely fast interpreter.
  
  
• Open source language and already used and tested by many users.
  
  
• Procedural language (like C or BASIC). NOT multi-paradigm supermarket! (multi-paradigm languages are hard to maintain and overwhelmingly bloated).
  
  
• Suitable for beginners and professional programmers.
  
  
• ...

There's more, but that's enough for now. Unless you use it - you'll never understand.

Tags:
Euphoria 3

Some knowledgeable programmers "complain" that in Euphoria 3 the hardware double data type is simply named atom!

Well, as far as I can tell, in Euphoria 3 there are no hardware data types at all:

Euphoria integer is a 31-bit integer, not a 32-bit hardware integer.

Euphoria atom can be either 31-bit integer or 64-bit double at run time, therefore it is not a 64-bit hardware double.

Conclusion:

The data types in Euphoria 3, integer, atom, sequence, cannot be compared to data types in other programming languages. i.e. integer is not a 16/32/64-bit hardware integer; atom is not necessarily a 64-bit hardware double; and sequence is definitely not a traditional array of successive elements of the same data type/structure; a sequence is dynamic data type - not static and not predefined. 알았어?

Tags:
atom, double

They simply "gone with the wind". Why? disappointment.

When OpenEuphoria Version 4.0.0 was released at December 22, 2010, I personally, and I'm honest, could not believe my eyes: the only good part of it was taken from Euphoria 3. IMHO. I did not like anything about it. I guess that I was not the only one.

No offense. Open Euphoria group is made of professional and talented programmers. They could've made a great work just by listening to Robert Craig of RDS. Yet pride is a poison that kills its owner.

Tags:
OpenEuphoria, Euphoria 3

If you like programming or if you simply interested in it, no matter what your background is, then Euphoria 3 programming language is probably something you've never heard about, and you may want to learn it.

For a professional programmer:

You probably know already EVERYTHING, right? So... it's getting Boring. Tedious. Job. Medals. Money.

Euphoria 3 can replace a lot of automated scripts that you are writing in lots of cryptic languages, with lots of secret and sacred punctuation marks and top-secret tips, which only few gurus can tell about. Isn't it? If you're working with Linux system then Bash (GNU Bourne-Again SHell) must be one of those ancient hieroglyph scripts. No doubt.

Why don't you learn Euphoria 3 in less then few hours, and start writing professional, readable, maintainable, very powerful, simple, short and fast scripts? Euphoria 3 can replace all other languages which you may use on Linux. The system() and system_exec() Euphoria 3 commands can call any GNU utility as well.

Think about it: how much time you waste on ancient hieroglyph scripts? Do yourself a favor and use Euphoria 3 for writing scripts. Later you may use it for writing larger programs as well.

For a beginner in programming:

If you just wanna tell the computer to do things; or if you wanna write programs without spending few years exercising hieroglyph scripts (programming languages); or if you actually want to enjoy programming... Euphoria 3 is the answer.

P.s.
Personally I found Euphoria 3 very late, in 2010, more or less, after writing programs in few flavors of Microsoft Basic, some are commercial programs; I've also enjoyed ladder programming for PLCs (Programmable logic controllers), where you can really tell big machines how to operate... that was my favorite type of programming, yet short.

I've learn few more languages (C, Assembly, SQL, Bash, Python, Java, etc), and forgot them quite fast (very fast). When I found Euphoria 3, out of frustration, I found what I was looking for. Not another cliche - but a profound programming language, an art. I like art so I gave it a try and realized that it is truly MUCH more simple then BASIC and obviously FAR MORE rapid then sacred languages such as C++.

Tags:
Euphoria 3

Yes.

• 1. Private scope: any variable declared inside a subroutine (procedure, function or type), is private to this subroutine only. i.e. it's visible and accessible only to this routine.
  
  
• 2. Local scope: any variable, constant or routine that you declare without the global keyword is local only to the module (source file). i.e. it is visible and accessible by all routines and local code in this module.
  
  
• 3. Global scope: any variable, constant or routine that you declare with the global keyword is visible and accessible by your entire program, i.e. by all modules. You must use the include keyword (directly or indirectly) to access something global.
  
  
• 4. for loop counter variable: the counter variable of a for loop is declared and initialized automatically since it is always an atom type variable, and it is private to the for loop. i.e. it is visible and accessible only inside the for loop.

P.s. Private overrides Local. Local overrides Global.

But in some other programming languages there are many more scopes...!

So what? bloated syntax leads to bad programming skills and unreadable code. i.e. you must learn how to name variables systematically if you want to write maintainable programs - and not rely on 70 different unmaintainable scopes to save you. Common sense.

Not long time ago Spaghetti-code did not have scopes at all - the programmer had to name his variables properly and systematically. That's the spirit.

Even today, in 2020, any industrial PLC (Programmable logic controller) that I've seen, didn't have scops (all global) ... And guess what? PLCs are everywhere! From Escalators, Elevators, to Parking Lots, to playgrounds, factories, restaurants... Your life is in the hands of a little industrial computer (PLC) that was programmed without using any scope at all!

To sum up:

Programming languages are overwhelmingly bloated today. Full of "shortcuts".
If you wanna be a good programmer then learn how to write a program without all this modern bullshit. You don't need it. All you need is discipline, consistent and systematical coding style - not a pile of keywords and unmaintainable syntax.

Tags:
scope

One of the most important aspects of Euphoria 3, among many others, is that Euphoria 3 is passing arguments to routines (procedure, function, type) always By Value.

Under the hood, sequence and floating point numbers are passed By Reference. This, among other aspects, makes Euphoria a very fast and efficient interpreted language.

Now - What's the big deal? BASIC allowing both Pass By Reference and Pass By Value, as well as C and C++... isn't it great that you're able to choose?

The answer is NO.

C and C++ languages are almost low level languages, or let's say - middle level languages, therefore they must include very hard to maintain low level features, such as different ways to pass variables to routines.

High level languages, such as BASIC, should have never allow Pass By Reference to be exist, to begin with!

Pass By Reference saves you few minutes of programming. But maintaining a program takes much more time then writing a program! And... as you could guess: Pass By Reference is the worst nightmare for the maintainer of your program - even if the maintainer is yourself!

Pass By Reference is an invisible feature of the language that completely throwing to the trash the concept of private variables... i.e. Pass By Reference is modifying the variables of the calling routine silently and invisibly - and what would you call it? What scope is it? Private? Local? Global? Export? Import? What??? NO. It's not a scope at all. It is a low level feature that exist in low level languages for a good reason - yet it should NEVER be exist in any high level language.

All I can say is that Pass By Reference is modifying variables invisibly, therefore it leads to lots of bugs when you write the program - and it is a nightmare when you maintain the program, i.e. since it is an almost invisible feature, you must check each variable of each routine to see if: was it passed by reference? or was it passed by value? The highly important concept of private scope is thrown to the trash - that's crazy.

Euphoria 3 is a very high level language, safe, readable and easy to maintain. Low level features such as "Pass By Reference" are the antithesis of readability and maintainability.

P.s. BASIC had to Pass By Value by default and allow Pass By Reference using a very visible and clear syntax... (Euphoria 3 does not need it anyway).

Tags:
reference, value, function, procedure