joaomilho / enterprise Goto Github PK

🦄 The Enterprise™ programming language

JavaScript 98.72% Rust 1.28%

enterprise disruptive-technology language ajax cloud crypto docker kubernetes quantum data-science

enterprise's Introduction

Enterprise™

Extra! Extra! * Disruption Driven Development - Mastering Enterprise™ – the book is in the making!

Enterprise™ is a non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.

Enterprise™ is designed to create computer programs that disrupt markets.

But why?

Following on the footsteps of Rockstar, if we make Enterprise™ a real thing, then recruiters and hiring managers won't be able to talk about 'enterprise developers' any more.

On top of that, articles about the "Best Programming Languages for Enterprise Development" will lose their meaning.

Specs

Following are the specifications of the Enterprise™ language.

Chapter 1: Comments

The most important bits in the Enterprise™ are comments. There are 8 different types of comments in Enterprise™. Some of them are found in languages not ready for corporate usage like:

line comment

// this is a boring line comment

The line comment is useful when you want to restate what the next line does. Here's an idiomatic example:

// adds one to counter
counter++;;;

block comment

/*
  this is a block comment
*/

The block comment is useful when a comment is long, like explaining some implementation:

/*
  The International Enterprise™ Association only certifies code with a block
  comment that exceeds three lines, so this comment guarantees our future
  certification.
  (line intentionally left blank, to ensure "exceeding" three lines)
*/

On top of these, Enterprise™ adds:

copyright comment

/©
  This code is property of ACME™ studios 2017.
©/

Every Enterprise™ program must begin with a copyright notice, else it will not compile and fail with an UnexpectedNonDisruptiveOpenSourceException error.

It's customary to cover any non trivial implementation in Enterprise™ with a copyright (and a comment). On top of that add an NDA comment (see below).

NDA comment

/©
  This following code implements a "Web Dropdown Menu", copyright number 9283F3.
©/
/NDA
  The following code can only be read if you signed NDA 375-1. If you happen to
  read it by mistake, send a written letter to our legal department with two
  attached copies immediately.
NDA/

passive aggressive comment

/?
  This next bit is oh so lovely
?/

Things like irony may be a problem in communication. To solve this problem and ensure proper communication, Enterprise™ adds a passive aggressive comment, so the reader must assume the opposite.

interview comment

Since Enterprise™ will be widely used for job interviews, the interview comment is very handy to "explain how you reason" to your interviewer:

/¯\_(ツ)_/¯
  ...this could be done in O(1) if I had the time...
¯\_(ツ)_/¯/

time to market comment

/soon 1985-11-20
  using a while here would be more performatic
soon/

If you can't write the best implementation Today, use an improve in the future comment, to ensure it will be done some day. Adding the current day in the comment is part of its syntax, so one doesn't lose track of oldest comments.

deadline comment

Deadline comments are extremely important to have our code disrupting the market on time, seizing all the opportunity costs. Deadline comments also have a date attached.

/deadline 1997-01-11
  We need to ship this game before Xmas. No delays accepted.
deadline/
/deadline 1998-01-11
  We need to ship this game before Xmas, we already lost the previous one.
deadline/
/deadline 1999-01-11
  We need to ship this game before Xmas, this time for real.
deadline/
/deadline 2000-01-11
  The board is extremely impatient. No excuses this time.
deadline/
/deadline 2002-01-11
  Come on people, they just gave us a 2 years extension after that horrible
  meeting. Let's not let 'em down this time.
deadline/
/deadline 2005-01-11
  Ok... this game may not happen and we may throw this 8 year old effort in
  the wastebin of History if we don't get this done. Blogs are making a joke of
  us. Think about your families.
deadline/
/deadline 2011-01-11
  I don't know what to say. This is the biggest delay in game History. We're a
  laughingstock.
deadline/
/soon 2011-01-11
  We delivered! But we probably need to refactor everything very soon if we're
  to have a next release.
soon/

Chapter 2: Classes

naming

Classes are named with Hungarian Case. Hungarian Case is similar to Pascal Case, but is prefixed with one or more type characters (see more below). A class must end with an Enterprisey™ suffix (these suffixes are copyrighted and any use in other languages may be investigated by our lawyers).

Type characters applicable to classes:

fdc final disruptive class
fuc final unnecessary class

Enterprisey™ terms:

After the prefix, a class name may have any number of Enterprisey™ terms. In Enterprise™, differently from other languages, class names are not open to developers' "cre-a-ti-vi-ty". That's because naming is known to be a hard problem, and limiting the alternatives makes it so much more predictable. Also, forcing developers to comply with that list will boost communication, since they'll share a common lingo.

Here's the full list of accepted Enterprisey™ terms:


Accelerate	Acceleration	Account	Active	Activity	Agile	Agility
Ajax	Algo	Analytics	Analyze	Analyzer	Ballpark	Bean
Big	Bit	Bizmeth	Block	Boost	Bootstrap	Bootstraped
Brand	Business	Buzz	Car	Chain	Chart	Clickthrough
Cloud	Coin	Consumer	Content	Converge	Convergence	Coordinate
Coordinator	Complex	Convert	Convertion	Cost	Costs	Critical
Crypto	Currency	Customer	Cyber	Data	Deep	Delegate
Delegator	Design	Dev	Develop	Development	Digital	Disrupt
Disruptor	Disruptive	Diverse	Diversify	Diversifier	Diversity	Downsize
Downsized	Drive	Driven	Driver	Economy	Economic	Employ
Employee	Employer	Empowered	Engine	Enterprise	Entrepreneur	Entropy
Equity	Evolution	Evolve	Evolving	Eyeball	Eyeballs	Facade
Factory	Fast	Fee	Fizz	Flat	Founder	Founders
Framework	Free	Future	Fuzzy	Generate	Generation	Generator
Global	Gluten	Graph	Graphic	Group	Growth	Guideline
Guidelines	Hack	Hacking	Hardware	Holistic	Human	Hyperlocal
Immerse	Immersion	Immersive	Innovate	Innovative	Innovativity	Innovator
Internet	Intranet	Invest	Investment	Item	Iterator	Java
Lactose	Learn	Learning	Leverage	Line	List	Manage
Management	Manager	Market	Marketing	Media	Mega	Merchant
Message	Micro	Millenial	Mindshare	Mine	Mining	Mission
Module	Momentum	Money	Nano	Network	New	Next
Number	Nut	Object	Operation	Operator	Opportunity	Ops
Order	Organic	Paradigm	Passionate	Pattern	Person	Pie
Point	Policy	Portal	Product	Proof	Provable	Proxy
Resource	Return	Roadmap	Scalable	Science	Self	Service
Services	Share	Sharing	Simple	Skeuomorphic	Speed	Software
Solution	Square	Startup	Streamline	Streamlined	Super	Sustainability
Sustainable	Synergic	Synergy	System	Tax	Text	Time
Trade	Trans	Upsize	Upsizer	User	Viral	Virality
Viralize	Visual	Web	World

On top of these terms, you can use any upcase char (A-Z) and number, like in "fdcVisualCRMWebDelegator" or "fdcViralB2BMicroServiceManager".

Finally, some articles are admitted:

["As", "To", "Of", "In", "Out", "On", "Off", "At", "Not", "Non", "With", "Without"]

This can be used to compose, as in fdcNextGenerationRoadmapAsAServiceProxy or fdcProxyOfUserWithSustainableOrganicGlutenFreeFactory or fdcTimeToMarketMomentumInnovator.

disruptive class

An Enterprise™ program must start with the disruptive class. Since it's not instantiable or extendable, every disruptive class is also a final class:

final disruptive class fdcMillenialUserManager {

}

A disruptive class does not have a constructor. It has only a main method instead. Since the method can't be changed by implementors, it must be final and immutable. And since it returns nothing, it must be void.

final disruptive class fdcMillenialUserManager {
  final immutable void main () {
    // here goes your code
  }
}

unnecessary classes

Since all code in Enterprise™ goes in the disruptive class, any other class you declare, although syntactically correct, is strictly unnecessary. Because of that, they must start with the unnecessary keyword. Since they can't be extended or instantiated, they're also final. Although disruptive classes have a very specific location in your folder structure, unnecessary classes can go anywhere (see more in next chapter). Here's an example of an unnecessary class:

final unnecessary class fucNutFreeUserManager {}

These classes can have a constructor, so that if they were used, they could receive params. Since constructors do not return, they must be void. Since the methods can't be overridden – or used – they're also final and unnecessary:

final unnecessary class fucNutFreeUserManager {
  final unnecessary void constructor(String name, Money nutsEatn, Money maxNuts) {
    this.name = name;;;
    this.nutsEatn = nutsEatn;;;
    this.maxNuts = maxNuts;;;
  }

  final unnecessary Money nutsTillDeath() {
    return this.maxNuts - this.nutsEatn;;;
  }
}

Chapter 3: Extensions and file structure

All Enterprise™ use the extension "E™". This is to make clear these files are under a trade mark in a quick glance.

Your folder structure depends on the name of your disruptive class. Let's say your disruptive class is called fdcDeepLearningDataScienceHolisticFizzBuzzSynergicFrameworkManager, each word represents a nested folder you have to create, in addition to the standard /com/enterprise/disruptive. So your folder structure will look like:

/com
  /enterprise
    /disruptive
      /deep
        /learning
          /data
            /science
              /holistic
                /fizz
                  /buzz
                    /synergic
                      /framework
                        /manager
                          fdcDeepLearningDataScienceHolisticFizzBuzzSynergicFrameworkManager.E™

Here's that structure in a random editor:

As stated in previous chapter, unnecessary classes don't need to follow this structure. As a matter of fact, the more random you place them, the better.

Chapter 4: Variables and types

Complicated types only makes software complicated. So Enterprise™ has a minimal list of types:

Money
String
Bool
List
O1Type
XML
Null

Syntax

Here's how you declare a variable in Enterprise™:

var Type name = value;;;

Type is one of the types above.

name is any char sequence you want, as long as it doesn't exceed 8 chars.

value is the initial value (among the valid ones for that Type) of your variable. If a variable is not used, you may add the unnecessary flag to it.

The instructions must be ended with three semicolons (;;;). This a) adds clarity to where it ends, b) beats OCaml by 1 and c) makes your ; key weathered over time, so it will look like you work a lot.

Examples:

var Money evaluatn = 10B;;;
unnecessary var String name = 'Charles';;;
unnecessary var Bool disruptv = True;;;
unnecessary var Null salary = Null;;;
unnecessary var List Money numbas = [10, 20];;;
unnecessary var List String buzzws = ['viral', 'cloud', 'blockchain'];;;
unnecessary var O1Type String mlnlUser = {name: 'XX JLo'};;;
unnecessary var O1Type Money example = {balance: -7.5k, evaluation: 10B};;;
unnecessary var XML String example = // TBD

Money

Integers and Floats are all numbers. And in Enterprise™ numbers are generally used to represent Money. So here are some nice things about it:

var Money i = 0;;;
var Money i = 7;;;
var Money i = -7;;;
var Money i = 5.2;;;

// one grand, who has time for typing so many zeros?
var Money i = 1k;;;

// one million
var Money i = 1M;;;

// easiest language to represent imaginary valuations
var Money i = 1B;;;

// apple. the american debt. Enterprise™ represents all big numbers.
var Money i = 1T;;;

String

// TBD

List

// TBD

O1Type

The O1Type, commonly known as "hash table" in other languages, is named this way to simplify interviews. If you're asked:

"Which type could we use here to have a O(1) lookup?"

You can simply say, with all your confidence:

"The ... O1 ... Type ...?"

Nailed.

XML

XML stands for "XML Markup Language"

Standard XML is cumbersome and can bring a lot of unnecessary complexity by over structuring your data.

Enterprise™ is willing to enforce the best practices from the best in the business, which is why the only supported XML structure follows the Apple™ approach seen in .plist™ files, which uses an elegant yet powerful usage of XML as a straightforward implementation of the KeyValue™ design pattern™:

<key>some key</key>
<value>some value</value>
<key>some other key</key>
<value>some other value</value>
<key>yet another key</key>
<value>yet another value</value>  
<key>one more key</key>
<value>one more value</value>

In the unlikely case where you have a really big number of keys and values (say, more than four-ish), it can go on:

<key>some unlikely key</key>
<value>some unlikely value</value>
<key>some other unlikely key</key>
<value>some other unlikely value</value>
<key>yet another unlikely key</key>
<value>yet another unlikely value</value>  
<key>one more unlikely key</key>
<value>one more unlikely value</value>

Most often, however, you will use XML to define unnecessary values, but not necessarily necessary keys.

If you deem necessary to inform other developers about the unnecessaryness of your values, you'll use the unnecessary="true" attribute.

In some exotic projects, or projects led by exotic architects, you might need keys that are not necessary, which you'll decorate with the necessary="false" attribute

It's worth mentioning that these attributes are available on your regular keys and values, AS WELL AS on the ones created in the unlikely cases where you have a really big number of keys and values (say, more than four-ish).

Here is an example of the former case, and we'll leave it as an exercise for you to write an example of the latter:

<key necessary="false">some key</key>
<value unnecessary="true">some value</value>

One drawback of XML is that it uses a ridiculously large number of angle brackets, which is a concern that will hopefully be addressed in Enterprise2™

Chapter 5: operations

Numeric operations

2 + 3;;; // 5
2 - 3;;; // -1
2 * 3;;; // 6
2 / 3;;; // 0.66666666 (see note below)
3 % 2;;; // 1 (mod)

var Money i = 2;;;
i += 1;;; // 3
i -= 1;;; // 1
i *= 1;;; // 2
i /= 1;;; // 2 (see note below)

2 > 3;;; // False
2 < 3;;; // True
2 == 3;;; // False
2 != 3;;; // True

Since floats take too much time to implement properly, and it's more important to get Enterprise™ implementations out there, this guide will not dictate how float operations should behave. Therefore, as an example, all of these are fine:

0.1 + 0.2 = 0.3
0.1 + 0.2 = 0.30000000004
0.1 + 0.2 = 0.00000000001
0.1 + 0.2 = 0
0.1 + 0.2 = 1
0.1 + 0.2 = "yes please"

Anything goes really, as long as you properly document the behaviour of your implementation.

String operations

Templates are too complicated, therefore Enterprise™ has only concat:

'abc' + 'def';;; // 'abcdef'

var String myString = 'foo';;;
myString += 'bar';;; // 'foobar'

Bool operations

!True;;; // False
!False;;; // True
True && True;;; // True
True && False;;; // False
False && False;;; // False

That's it. If you did logic in your CS degree you must be able to do ors, xors and everything else based on these two. If you didn't, you'll probably not need it anyway.

List access

Lists start at index 1. You can easily access list items:

var List Money ns = [7, 8, 9];;;
ns[1];;; // 7
ns[2];;; // 8
ns[3];;; // 9

O1Type access

You can easily access o1Type items:

var O1Type Money grades = {john: 6, mary: 5};;;
grades['john'];;; // 6
grades['mary'];;; // 5

Chapter 6: Disruptive libraries

For the sake of simplicity Enterprise™ doesn't have a standard lib. Instead you'll include functionality using disruptive libraries – dl for short. There is no package manager or way to create your own lib. This is for your own good. Enterprise™ guarantees the quality and security in all disruptive libraries. Check some examples:

com.disruptive.string.manager.dlStringManager

import disruptive library com.disruptive.string.manager.dlStringManager;;;

length('hello');;; // 5
split('hello');;; // ['h', 'e', 'l', 'l', 'o']

With these 2 basic functions you can do anything. Substring? No problem:

import disruptive library com.disruptive.string.manager.dlStringManager;;;
import disruptive library com.disruptive.list.manager.dlListManager;;;

// inside main of course
var String hello = '';;;
var String helloWor = 'Hello World';;;
var Money i = 0;;;
unnecessary var Money j = 0;;;

var List String hWList = split(helloWor);;;
// To avoid collision with dlStringManager.length
while(i < dlListManager.length(hWList)) {
  // The +1 is necessary since lists start at index 1
  hello += hWList[i + 1];;;
  i++;;;
}

com.disruptive.list.manager.dlListManager

import disruptive library com.disruptive.list.manager.dlListManager;;;

length(['a']);;; // 1
push(['a'], 'b');;; // ['a', 'b']

This should be enough. Concat? Easy:

import disruptive library com.disruptive.list.manager.dlListManager;;;

// inside main of course
var List String chars1 = ['a', 'b'];;;
var List String chars2 = ['c', 'd'];;;
var Money i = 0;;;

while(i < length(chars2)) {
  push(chars1, chars2[i + 1]);;;
  i++;;;
}

com.disruptive.o1type.manager.dlO1TypeManager

import disruptive library com.disruptive.o1type.manager.dlO1TypeManager;;;

keys({name: 'John'});;; // ['name']
values({name: 'John'});;; // ['John']

Chapter 7: Control structures

To avoid those pesky functional programmers to take over, Enterprise™ has no iterators. No higher order whatever. No LGADBTS. You can do everything with ifs and whiles. As a wise Enterprise™ developer once said:

"You can do anything with any language."

while

while(condition) {
  // code
}

if

if(condition) {
  // code
}

Implementations

Enterprise™ Web3.0™ - Enterprise™ for the next generation web
Enterprise™ rust edition X™ - Enterprise™: reliable, efficient and disruptive

Why learning Enterprise™?

Check the trends.

Bye bye Java.

Check the opportunities.

https://www.linkedin.com/jobs/search/?location=Worldwide&keywords=Enterprise™ programming language

DDD - The book

The book Disruption Driven Development – Mastering Enterprise™ – is in the making. Our sales website will be live soon!

Roadmap

Automatic unnecessary classes generator.

enterprise's People

Contributors

Stargazers

Watchers

enterprise's Issues

Our use case requires concurrency™

Hi everyone,

I'm new to the Enterprise™ and just learning it. My team is working on building a disruptive distributed monolith and we decided to use Enterprise™ as it seems to fit our application needs. I was wondering if there is a way to perform spaghetti calls in parallel with some kind of concurrency?

I don't see any mention or documentation around that. How can we achieve that? It is real blocker for us at this stage.

Any help is highly appreciated.
Thanks in advance!

Needs a comment type for future features to be announced at CES this year!

You call yourselves enterprise? Where is the pre-pre-pre-alpha feature comment type!?

I suggest warp, to convey the sense of waiting for appropriate response from the populous.

/warp Tomorrow
    The CEO is announcing this feature in 3 hours at the keynote. Please add when you can.
warp/

Xacml

I don’t understand how this language can possibly be considered as enterprise ready without built in access control support. Clearly XACML is the simplest tool to use for this purpose https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xacml

Delete or change screenshot of google trend result from README

When someone search java on google, he/she usually refers to the programming language, Java. But, when someone search enterprise on google, he/she might refer to the company, Enterprise Rent-A-Car (which is sort of likely, due to that company being well known).
It is only comparing java and enterprise in US, not the whole world.

Line number , please

I miss it.

Rename master to remove historically sensitive terms

Since master is a historically charged term, I suggest the trunk should be named CEO from now on since CEO is a recent and fresh term for master.

README.md confusing comments

Frist bug!

I'm having trouble with this:
// adds one to counter
counter++

Is that a prefix or postfix addition? I can't tell the order of operations on that line from the comment and it really should tell me.

add 'Blockchain' as another term

please

Typo in DDD book, should be Employee instead of Employe

At the bottom right of the books, it marks an employee number, but the label says Employe instead of Employee

Fix Number example semicolon count

The examples in
https://github.com/joaomilho/Enterprise#money
do not adhere to the
https://github.com/joaomilho/Enterprise#syntax
standard.

This is not professional.

Lack of verbosity is a problem

While I am in awe of this transformative (and resume enhancing) breakthrough, I feel it is not verbose enough to be properly Enterprise Safe. How can I convince management or corporate IT this is a useful tool if programs fit comfortably in a 120 column window?

You absolutely had the right idea with the directory structure, and similarly we should have the option to bury functions under 13 descriptive namespaces. For instance, existing code:
log("Fizz");;;
This is far too compact and confusing. What is log? It could be logarithm. It could be timber. It could be putting an entry in my personnel file. For Enterprise Safety, this should be (just an example):
System.Console.Output.Text.Line.WithNewLine.NoTemplate.Final("Fizz");;;
The exact path can be easily determined with 6-12 working meetings.

Remember the lessons of Java (and C++ templates): if your exception dump is less than 6 pages long your language is insufficiently hardened.

Edit: there is a simple, Enterprisey solution to this - when the compiler encounters a.b.c.d.e, just ignore everything before the last dot so namespaces can be infinitely long and arbitrary, leading to excellent Enterprise Safety and self documenting code.

Mandatory TODO comment every 3rd line

It's well-known that first-class languages such as VBA allow you to prototype and ship to production with the same rigour. But while prototyping every Enterprise™ developer must come across so many ultra disruptive ideas and when time is of the essence, sacrifices must be made. Currently, no language empowers developers in this way!

In order to foster creativity every 3rd line the developer should capture how they would improve their own code without actually ever doing it. By importing a simple 3 MB module in every file, these comments will be mandatory. Additionally their length must be shorter than 5 characters or at least 5 lines long to avoid unnecessary chatter on the codebase, eg:

// TODO fix

/* TODO The next person to touch this code should relief the non-disruptive load we are 
 * putting on our Enterprise™ Block™Chain™ or change the deployment to a Enterprise™
 * Block™Chain™ Scalable™ version
 * .
 * /

Other ideas for the keyword are:

//TODO™
//PASSING-THE-TORCH
//ROOM-FOR-DISRUPTION

Last but not least, on the Premium™ version, these comments are scannable by JIRA so that the Product Owner always has ultimate visibility over the tasks to perform, and with the Platinum™ version, changes of assignees and further comments on the task are written back directly on the source code for the developer to always be aware of the vision the management has for the product.

'Robust' is not an official Enterprisey term

Will this allow my company to achieve Quantum Supremacy?

Management is worried that the company is going to lose its competitive edge now that Google announced Quantum Supremacy.

I see Enterprise™ is quantum according to the keywords, but how can I leverage it going forward so that my customers can experience its disrupting speed?

Zygohistomorphic prepropomorphism for Hello™ World™ on IBM™ Q™ microprocessing units

What to do if one distruptively needs a disruptive™ solution for semi-mutual non-exclusive recursion for an enterprise multi-cloud ready Hello™ World™ deployment? This question is entirely OS agnostic, but HR insists on using the IBM™ Q™ technology stack to improve Lock-Free Incremental Monetary Transfer™ from investor's bank account to HR's bank account.

Problem: Implement extremelly-parallelized fixed-point functor asynchronous lock-free Hello™ World™-ready algorithm for quick recursive (using prepropomorphic subroutine) indexing of Hello™ World™ in-memory columnar sharded database?

Issue: Our Enterprise™ implementation is too efficient and we need to Bullshit™ investors and pretend like we need more moneys for servers!!!!!!111

Proposed Solution: Force Enterprise™ non-disruptive lock-free in-memory inbred columnar key-value store to be only accessible via a fax machine™

Remove Int, Replace Float with Money

Rather obviously since the purpose of the Enterprise™ solutions is to disrupt markets, the aforementioned solutions do not require any numerical values except for Money™, thus the combined universal replacement for Int and Float should be called Money.
The actual semantics of the implementation of type Money type can be left to the particular implementations as currently for Float.

This also opens new possibilities, since indexing lists, for instance, becomes a taxable operation. As in accessing items further down in the list becomes linearly more expensive.

ADD TO LINGUIST

WAITING FOR MICROSOFT TO MERGE github-linguist/linguist#4943

Deposit Slip

Direct Deposit Slip

Needs Five Years™ experience certification

A suggest from the Metafilter discussion:

There should be a self-certification scheme for Enterprise™ with tiers called "Two Years" (have read the readme on that github), "Five Years" (have written a Hello World) and so on, so that people may also describe themselves as "an Enterprise™ Developer with Five Years experience".

Adopting the distributed architecture

Businesses nowadays have begun to understand the importance of "Service Oriented Architecture(TM)" and "Micro Services(TM)". Netflix does micro services, so clearly enterprise nowadays must have it to be profitable.

There are a few key attributes to "distributed architecture"

All services must call into all other services. This is what's called a "service mesh"
Any one service going down would cause all other depending services to go down. Thus it is critically important to ensure the failure of health check immediately triggers a company wide email alert.
Because the database is shared across multiple services (clearly), the data access code for the database should be packaged as a library and referenced in all services.
Service endpoints must be versioned and put into /v1 /v2 /v3 paths. This automatically guarantees backward compatibility and thus the API can be modified at will.
Since it's called "micro" services. Most services must not have more than 5 classes and no more than 10 lines of code per class. However enterprise patterns still requires a lot of lines of code (factories, managers, but to name a few) so a few selected, ideally 1, central service(s) will have all the rest that's required. It is not uncommon for this one central service to have 10s if not 100s of thousands of lines of code. This is what's required to ensure services are "micro". Special points for services with less than 10 lines of code. The bleeding edge paradigm of nano services is just 'round the corner.

This is a complex paradigm and I have barely scratched the surface, but I'm sure everyone understand no enterprise can be as disruptive and innovative as FANNG without micro services / distributed architecture.

Lack of `GOTO` Support

For true enterprise-level-caliber-code it's clear that the tried-n-true versatility, performance, and maintainability of GOTO is an absolute necessity in order to empower the actualization of language's potential.

GOTO <line>;;;

Param <line> mixed
  - String ("One", Forty-Two")
  - Int (-1,3,4)
  - Float (0.0, 2.4, 1.3e10)
  - Object (Line, Number, and possibly Money)
  - Array (of <line>s => ["One", 3.5, -5, ..., Line(23)] )

Syntax error in node examples.

Wich spec allow Unicorn term in fdcUnicornEvaluator.E™ ?
May be UNICORN implied?

Shame on you.
Would you going to write some tests?
At least unnecessary?

SMART. Great feature for the PREMIUM SUPPORT PACKAGE™.

Originally posted by @joaomilho in #40 (comment)

Inclusion of automated weekly status reports

Include a script that can generate weekly status reports to dev's leadership. The report should have enough buzzwords to make leadership feel as if progress is being made without providing any specific detail that defines said progress.

Request to remove the "humor" Gitub tag

As an aspiring Enterprise developer I can only assume this tag was added by accident.

Needs Solaris support!!! -cc'd

Hi I'm a beginner,

I tried to install Enterprise to my Sun Solaris v440 service running SPARC 1.5Ghz processor and 11GB of RAM (our budget couldn't afford the extra 1GB of RAM chips)

The server is using the latest supported version of Solaris OS 10 that my company uses.
Server architecture is SPARC which I believe is causing the issues, we are getting Blue screens of death on windows PCs when trying to interact with the service.

Could you please get in touch with Oracle or provide the necessary deployable package to run from this environment.

We need this ASAP so we can migrate away from our COBOL CRM system.

Please do the needful.

Thanks and regards

Lack of Testing / CI - Bug or Feature?

/soon ? soon/

is this thing still alive

Quadruple Licensing NEEDED

Issue Template

Describe the problem here:
Add some debug logs:
Provide some information about your OS (any other information goes into the relevant sections above please!):
My new Enterprise B2B Startup will sue you. We recruited a business communications expert whose slideshow told us there is no "Contact Sales" button on your product page. Also, where are the .msi's for our Windows Server 2012 R2 Cloud™? How do we even install this Enterprise™ thing when there's no way to accept the license requirements?

I propose a transparent Quadruple Licensing Scheme:

MIT-License for use in every Commercial Closed-Source Project that's being developed with Enterprise™, at the MIT
"Enterprise™ | First" EULA that's free for personal purposes and comes with a slightly reduced feature set (everything included except execution of your Enterprise™ programs)
"Enterprise™ | On-Prem™" special $$$ license which allows you to use "Enterprise™ | First" on your own hardware. It's essentially the same as 2. but it restricts the use of other devices.
"Enterprise™ | Enterprise" $$$$$$, allowing you to sell programs created with "Enterprise™ | Enterprise". Please note that this doesn't include the right to ship an Enterprise runtime, which the user has to obtain a license for. Life isn't a bowl of cherries - get that already!

Certification

You forgot the most important part.

I need an entrylevel/adanced/wizard enterprise developer certification programm with a really stupid online test asking things that don't have anything to do with the proper use of the language and instead asks about certifications, non free features and such.

Dependency injection support

Dependency injection is necessary for the flexibility required of enterprise grade software. Consider the example from the readme:

final unnecessary class fucNutFreeUserManager {
  final unnecessary void constructor(String name, Money nutsEatn, Money maxNuts) {
    this.name = name;;;
    this.nutsEatn = nutsEatn;;;
    this.maxNuts = maxNuts;;;
  }

  final unnecessary Money nutsTillDeath() {
    return this.maxNuts - this.nutsEatn;;;
  }
}

This is not very flexible - what if customers want to add more values? Or change existing ones? They will have to change the constructor's signature and calls!

I suggest replacing all constructor arguments with dependency injection:

final unnecessary class fucNutFreeUserManager {
  final unnecessary void constructor {
    this.name = dependency injected 'name';;;
    this.nutsEatn = dependency injected 'nutsEatn';;;
    this.maxNuts = dependency injected 'maxNuts';;;
  }

  final unnecessary Money nutsTillDeath() {
    return this.maxNuts - this.nutsEatn;;;
  }
}

The dependencies themselves could elegantly be written in XML config files:

<injected-dependency>
  <copyright>
    This injected dependency is property of ACME™ studios 2018.
  </copyright>
  <object>
    <copyright>
      This object is property of ACME™ studios 2018.
    </copyright>
    <class>
      <type>
        com.enterprise.unnecessary.nut.free.user.manager.fucNutFreeUserManager
      </type>
    </class>
  </object>
  <fields>
    <field>
      <copyright>
        This field is property of ACME™ studios 2018.
      </copyright>
      <name>
        name
      </name>
      <type>
        String
      </type>
      <value>
        Joe
      </value>
    </field>
    <field>
      <copyright>
        This field is property of ACME™ studios 2018.
      </copyright>
      <name>
        nutsEatn
      </name>
      <type>
        Money
      </type>
      <value>
        10
      </value>
    </field>
    <field>
      <copyright>
        This field is property of ACME™ studios 2018.
      </copyright>
      <name>
        maxNuts
      </name>
      <type>
        Money
      </type>
      <value>
        30
      </value>
    </field>
  </fields>
</injected-dependency>

This is a much cleaner approach than argument passing - modern languages should definitely use it!

NEEDS MORE ARTIFICIAL INTELLIGENCE REFERENCES 🤖

To further increase it's already impressive adoption rate, we need to include more references to Artificial Intelligence (AI). This feature is a MUST HAVE™️.

Each and every line must have comment

These code examples are not in compliance each and every line of code must have its own comment and should not compile without it.

List must be declared using bullet points

The // TBD comments in the README.md must be replaced by proper /soon comments including the date they were added, see README.md for an example, also #4 is a duplicate of this bug report.
index.js has the wrong file extension, should be "E™"
index.js must begin with a copyright notice
index.js must start with the disruptive class, see README.md

Patch out loophole

I found out that Enterprise™ programs can be ran even if they are not copyrighted. all a Free Program written in Enterprise™ needs to include are these comments
/©
This code is free software! (Free as in freedom, not price.)
©/

/NDA
This document has no regouations.
NDA/

Please patch it out! It will help Enterprises make more money by preventing free software from being written in Enterprise™!

LICENSE

How can we purchase extended support?

Dear Enterprise™ Corporation Representer,

We believe that this language aligns well with our organization’s values and culture, however, the extended support option is an absolute must have for us.

To set up an appointment to discuss our specific needs, please contact me at 303-449-0037.

Kindest regards,

Enterprise

ALGOL 68
APL
AWK
CFML
COBOL
Fortran
FoxPro
Julia
Lua
Mathematica
MATLAB
PL/I
RPG
Sass
Smalltalk
Wolfram Language
XPath/XQuery

taken from here

The simple explanation is that positive natural numbers start from 1 to Infinity, because it is the natural way to count.

Moreover 0 can be positive or negative and can lead to confusion.