Enterprise

额外的！额外的！ *破坏驱动的开发-Mastering Enterprise ™ - 这本书正在制作中！

Enterprise ™是一种非确定性的无确定性™TURED-COMPLETE-ish™，量子量的the-box™编程语言。

Enterprise ™旨在创建破坏市场的计算机程序。

跟随Rockstar的脚步，如果我们将Enterprise ™成为真实的事情，那么招聘人员和招聘经理将无法再谈论“ Enterprise开发人员”。

最重要的是，有关“ Enterprise发展最佳编程语言”的文章将失去其含义。

• 规格
  • 评论
  • 课程
  • 扩展和文件结构
  • 变量和类型
  • 运营
  • 破坏性库
  • 控制结构
• 实施
• 为什么要学习Enterprise ™？
• 破坏驱动的发展 - 这本书
• 路线图

以下是Enterprise ™语言的规格。

Enterprise ™中最重要的位是评论。 Enterprise ™中有8种不同类型的评论。其中一些是在语言中发现的，但尚未准备好以：

 // this is a boring line comment

当您想重述下一行的功能时，行评论很有用。这是一个惯常的例子：

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

 /*
  this is a block comment
*/

当评论漫长时，块评论很有用，例如解释某些实现：

 /*
  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)
*/

最重要的是， Enterprise ™添加：

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

每个Enterprise ™程序都必须从版权通知开始，否则它不会在UnexpectedNonDisruptiveOpenSourceException错误中进行编译和失败。

习惯上涵盖具有版权（和评论）的Enterprise ™中的任何非微不足道实现。最重要的是添加了NDA评论（请参见下文）。

 /©
  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/

 /?
  This next bit is oh so lovely
?/

讽刺之类的事情可能是沟通中的问题。为了解决此问题并确保正确的通信， Enterprise ™添加了被动的积极评论，因此读者必须相反。

由于Enterprise ™将被广泛用于求职面试，因此面试评论非常方便地“向面试官解释您如何推理”：

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

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

如果您今天无法写出最佳的实施，请在将来的评论中使用改进，以确保有一天会进行。在评论中添加当前一天是其语法的一部分，因此不会失去最古老的评论的跟踪。

截止日期的评论非常重要的是，我们的代码按时破坏了市场，扣押了所有机会成本。截止评论还附有日期。

 /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/

课程命名为匈牙利案。匈牙利案件类似于帕斯卡案，但前缀有一个或多个类型的字符（请参见下面的更多）。班级必须以Enterprise Y™后缀结尾（这些后缀是版权的，并且我们的律师可以研究其他语言的任何用途）。

类型适用于类的字符：

• fdc最终破坏性课程
• fuc最终不必要的课程

前缀之后，类名称可能具有任意数量的Enterprise Y™项。在Enterprise ™中，与其他语言不同，类名称不向开发人员的“ CRE-A-TI-VI-TY”开放。这是因为已知命名是一个严重的问题，并且限制替代方案使其更具可预测性。同样，强迫开发人员遵守该列表将增加通信，因为他们将共享一个共同的术语。

这是接受Enterprise Y™术语的完整列表：

在这些术语中，您可以使用任何Upcase Char（AZ）和数字，例如“ FDCVISUALCRMWEBDELEGATOR”或“ FDCVIRALB2B2BMICROSERVICEMANAGER”。

最后，一些文章被录取：

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

这可以用作fdcNextGenerationRoadmapAsAServiceProxy或fdcProxyOfUserWithSustainableOrganicGlutenFreeFactory或fdcTimeToMarketMomentumInnovator 。

Enterprise ™程序必须从破坏性类开始。由于它是不可接触或可扩展的，因此每个disruptive类也是final一类：

 final disruptive class fdcMillenialUserManager {

}

破坏性类没有构造函数。它仅具有main方法。由于实施者无法更改该方法，因此必须是final且不immutable 。而且由于它没有返回，因此必须void 。

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

由于Enterprise ™中的所有代码都在颠覆性类中，因此您声明的任何其他类，尽管在语法上正确，这都是不必要的。因此，它们必须从unnecessary关键字开始。由于它们不能扩展或实例化，因此也是final 。尽管颠覆性类在您的文件夹结构中具有非常特定的位置，但不必要的类可以到任何地方（请参阅下一章中的更多内容）。这是一个不必要的班级的示例：

 final unnecessary class fucNutFreeUserManager {}

这些类可以具有构造函数，因此，如果使用它们，则可以接收参数。由于构造函数不返回，因此必须void 。由于这些方法不能被覆盖或使用 - 它们也是final和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 ;;;
  }
}

所有Enterprise ™都使用扩展“ E™”。这是为了清楚这些文件在快速浏览的范围内。

您的文件夹结构取决于您的破坏性类的名称。假设您的颠覆性类称为fdcDeepLearningDataScienceHolisticFizzBuzzSynergicFrameworkManager ，除了标准/com/ Enterprise /disruptive外，每个单词都代表您必须创建的嵌套文件夹。因此，您的文件夹结构看起来像：

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

这是一个随机编辑器中的结构：

如上一章中所述，不必要的类无需遵循此结构。事实上，将它们放置得越随意，越好。

复杂的类型仅使软件变得复杂。因此， Enterprise ™具有最少的类型列表：

 Money
String
Bool
List
O1Type
XML
Null 

这是您在Enterprise ™中声明变量的方式：

 var Type name = value ;;;

Type是上述类型之一。

name是您想要的任何字符序列，只要它不超过8个字符。

value是变量的初始值（在该类型的有效值中）。如果未使用变量，则可以向其添加unnecessary标志。

指令必须以三个分号（;;）结尾。 a）添加了清晰的结局，b）击败OCAML 1和c）使您成为您的;随着时间的流逝，钥匙会随着时间的流逝而风化，因此看起来您的工作很多。

示例：

 var Money evaluatn = 10 B ;;;
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.5 k , evaluation : 10 B };;;
unnecessary var XML String example = // TBD 

整数和浮子都是数字。在Enterprise中，通常用来代表金钱。所以这里有一些好处：

 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;;;

// TBD

// TBD

其他语言中通常称为“哈希表”的O1Type被命名为简化访谈的方法。如果被问到：

“我们在这里可以使用哪种类型的o（1）查找？”

您可以简单地说，充满信心：

“ ... O1 ...类型...？”

钉子。

XML代表“ XML标记语言”

标准XML很麻烦，可以通过构造数据来带来很多不必要的复杂性。

Enterprise ™愿意从业务中最好的实践实施最佳实践，这就是为什么唯一支持的XML结构遵循.plist™Files中的Apple™方法，该方法使用XML的优雅而强大的用法作为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> 

在不太可能的情况下，您拥有大量的钥匙和值（例如，四个以上），它可以继续：

 <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> 

但是，您通常会使用XML来定义不必要的值，但不一定是必要的键。

如果您认为有必要告知其他开发人员您的价值观的不必要性，则将使用unnecessary="true"属性。

在某些异国情调的项目或由异国建筑师领导的项目中，您可能需要不需要的密钥，您将使用necessary="false"属性进行装饰

值得一提的是，这些属性可在您的常规键和值上以及在不太可能拥有大量键和值的情况下创建的属性（例如，超过四个）。

这是以前情况的一个例子，我们将其作为练习，让您写一个后者的例子：

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

XML的一个缺点是它使用了大量的角度括号，这是一个有望在Enterprise 2™中解决的问题

 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

由于浮子需要太多时间来正确实施，因此获得Enterprise ™实施更为重要，因此本指南将不会决定浮点操作应如何行为。因此，例如，所有这些都很好：

 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"

只要您正确记录实施的行为，一切都会发生。

模板太复杂了，因此Enterprise ™只有Concat：

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

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

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

就是这样。如果您在CS学位上进行逻辑or则必须能够根据这两个做到或其他所有xors 。如果您不这样做，那么您可能不需要它。

列表从索引1开始。您可以轻松访问列表项目：

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

您可以轻松访问O1Type项目：

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

为了简单起见， Enterprise ™没有标准LIB。相反，您将使用破坏性库 - 简称DL包括功能。没有包装管理器或创建自己的LIB的方法。这是为了你自己的利益。 Enterprise ™保证所有破坏性库中的质量和安全性。检查一些示例：

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

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

借助这两个基本功能，您可以做任何事情。子字符串？没问题：

 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 ++;;;
}

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

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

这应该足够了。 concat？简单的：

 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 ++;;;
}

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

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

为了避免那些讨厌的功能程序员接管， Enterprise ™没有迭代器。没有更高的订单。没有lgadbts。 if S和S while您可以使用所有操作。正如明智的Enterprise ™开发人员曾经说过的那样：

“您可以用任何语言做任何事情。”

 while ( condition ) {
  // code
}

 if ( condition ) {
  // code
}

• Enterprise ™web3.0™ - 下一代Web的Enterprise ™
• Enterprise ™Rust Edition X™ Enterprise ™：可靠，高效和破坏性

检查趋势。

再见爪哇。

检查机会。

https://www.*linke**din.com/jobs/search/?location=worldwide&keywords = enterprise™编程语言

这本书的破坏驱动的发展 - 掌握Enterprise ™ - 正在制作。我们的销售网站很快就会直播！

1. 自动不必要的类生成器。