www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - D now has a dangerous competitor

reply bauss <jj_1337 live.dk> writes:
The following language is a dangerous competitor to D.

https://github.com/joaomilho/Enterprise
Aug 28 2018
next sibling parent Nicholas Wilson <iamthewilsonator hotmail.com> writes:
On Tuesday, 28 August 2018 at 08:39:20 UTC, bauss wrote:

 The following language is a dangerous competitor to D.

 https://github.com/joaomilho/Enterprise


Thats very funny, but I found Rockstar even funnier.
Aug 28 2018
prev sibling next sibling parent reply JN <666total wp.pl> writes:
On Tuesday, 28 August 2018 at 08:39:20 UTC, bauss wrote:

 The following language is a dangerous competitor to D.

 https://github.com/joaomilho/Enterprise


I often feel like this kind of 'jokes' are trying too hard. 
FizzBuzz Enterprise was fun when it first came out, and I know 
it's popular to hate on OOP programming, especially Java. But the 
fact is, a very big portion of software was built using OOP, and 
many of the hated design patterns have a place in programming. 
Sure, it doesn't provide witty one-liner quicksort examples, but 
when you have a group of people, having to integrate multiple 
webservices/databases, these kind of layered code architecture 
comes in handy.

Of course sometimes people go too far, trying to make the code 
generic and fit every usecase, breaking YAGNI.
Aug 28 2018
parent reply solidstate1991 <laszloszeremi outlook.com> writes:
On Tuesday, 28 August 2018 at 11:30:20 UTC, JN wrote:

 On Tuesday, 28 August 2018 at 08:39:20 UTC, bauss wrote:

 The following language is a dangerous competitor to D.

 https://github.com/joaomilho/Enterprise


 I often feel like this kind of 'jokes' are trying too hard. 
 FizzBuzz Enterprise was fun when it first came out, and I know 
 it's popular to hate on OOP programming, especially Java. But 
 the fact is, a very big portion of software was built using 
 OOP, and many of the hated design patterns have a place in 
 programming. Sure, it doesn't provide witty one-liner quicksort 
 examples, but when you have a group of people, having to 
 integrate multiple webservices/databases, these kind of layered 
 code architecture comes in handy.

 Of course sometimes people go too far, trying to make the code 
 generic and fit every usecase, breaking YAGNI.


Most of the hate towards OOP is misdirected. Java will be always 
slow because it always running in a VM, no structures so you have 
to rely on reference-type classes for everything. Other times 
it's on the developer. Thanks to my education, I first wanted to 
approach every problems in programming from an object-oriented 
viewpoint, since that was the only one we were taught (and I 
missed the classes on interfaces due to an incident, so I 
struggled to keep up).

You have to learn where to use what. I personally hate C and C++ 
precompiler macros more, which made porting LZHAM to D a 
nightmare sometimes. Some parts of the macros got completely 
eliminated since Fiber saves most things on the stack.
Aug 28 2018
parent reply Nick Sabalausky <a a.a> writes:
On Tuesday, 28 August 2018 at 21:57:28 UTC, solidstate1991 wrote:

 
 Thanks to my education, I first wanted to approach every 
 problems in programming from an object-oriented viewpoint, 
 since that was the only one we were taught.


Sounds like you were more or less lucky compared to average: For 
a long while, OOP wasn't just the only thing taught, it was 
frequent taught specifically to be "the one and only right way."

It's not so much OOP itself that's hated: It's the late 90's 
early 2000's obsession that OOP is the one right way to do 
EVERYTHING that gets a lot of (much deserved) hate.

I used to do a lot of OO myself (in fact, Tango was very heavily 
rooted in OOP design), but the more I use D2 and other things, 
the more convinced I am that there are just simply better 
mechanisms (provided the language in question supports them well 
enough) to get the benefits offered by traditional 
inheritance-based OOP, without so much of the now-well-known 
downsides. I'm 90% convinced that an equivalent of traditional 
Java-style OOP could be constructed out of these meachanisms 
without too much trouble, and is effectively a subset of them. If 
I were a grad student, I would totally do a thesis around that.
Aug 28 2018
parent reply bauss <jj_1337 live.dk> writes:
On Tuesday, 28 August 2018 at 23:27:09 UTC, Nick Sabalausky wrote:

 On Tuesday, 28 August 2018 at 21:57:28 UTC, solidstate1991 
 wrote:

 
 Thanks to my education, I first wanted to approach every 
 problems in programming from an object-oriented viewpoint, 
 since that was the only one we were taught.


 Sounds like you were more or less lucky compared to average: 
 For a long while, OOP wasn't just the only thing taught, it was 
 frequent taught specifically to be "the one and only right way."

 It's not so much OOP itself that's hated: It's the late 90's 
 early 2000's obsession that OOP is the one right way to do 
 EVERYTHING that gets a lot of (much deserved) hate.

 I used to do a lot of OO myself (in fact, Tango was very 
 heavily rooted in OOP design), but the more I use D2 and other 
 things, the more convinced I am that there are just simply 
 better mechanisms (provided the language in question supports 
 them well enough) to get the benefits offered by traditional 
 inheritance-based OOP, without so much of the now-well-known 
 downsides. I'm 90% convinced that an equivalent of traditional 
 Java-style OOP could be constructed out of these meachanisms 
 without too much trouble, and is effectively a subset of them. 
 If I were a grad student, I would totally do a thesis around 
 that.


Honestly C++ did OOP somewhat right, because it wasn't forced 
upon you, but C++ itself has design issues, that I think D has 
solved very well.

D does OOP better than C++, but D is still missing some very 
common OOP patterns.

See: 
https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


what C++'s behavior is, but I guess it doesn't matter in C++, 
because of friends.
Aug 28 2018
next sibling parent reply "Nick Sabalausky (Abscissa)" <SeeWebsiteToContactMe semitwist.com> writes:
On 08/29/2018 12:53 AM, bauss wrote:

 
 Honestly C++ did OOP somewhat right, because it wasn't forced upon you, 
 but C++ itself has design issues, that I think D has solved very well.
 
 D does OOP better than C++, but D is still missing some very common OOP 
 patterns.
 
 See: https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


Ugh, honestly, I'm getting really tired of seeing facepalm moments like 
that in D: Things that are CLEARLY either bugs or outright wrong design 
that wind up getting bizarrely defended instead of fixed.

I still enjoy developing in D far more than any other language. It's the 
only one that doesn't make me feel straightjacketed - or like I NEED a 
straightjacket. But all these facepalms are really making my forehead 
hurt...
Aug 30 2018
parent bauss <jj_1337 live.dk> writes:
On Thursday, 30 August 2018 at 07:01:11 UTC, Nick Sabalausky 
(Abscissa) wrote:

 On 08/29/2018 12:53 AM, bauss wrote:

 
 Honestly C++ did OOP somewhat right, because it wasn't forced 
 upon you, but C++ itself has design issues, that I think D has 
 solved very well.
 
 D does OOP better than C++, but D is still missing some very 
 common OOP patterns.
 
 See: 
 https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


 Ugh, honestly, I'm getting really tired of seeing facepalm 
 moments like that in D: Things that are CLEARLY either bugs or 
 outright wrong design that wind up getting bizarrely defended 
 instead of fixed.

 I still enjoy developing in D far more than any other language. 
 It's the only one that doesn't make me feel straightjacketed - 
 or like I NEED a straightjacket. But all these facepalms are 
 really making my forehead hurt...


I agree with that.

Then the discussions drag on for years before they finally have 
an implementation draft that is stalled for a few years more and 
then finally implemented, but by the time that has been done the 
people who wanted all those features has moved on to other 
languages etc. because they're tired of how long things drag out. 
The whole dicebot thread is a prime example.
Aug 30 2018
prev sibling parent reply Basile B. <b2.temp gmx.com> writes:
On Wednesday, 29 August 2018 at 04:53:59 UTC, bauss wrote:

 On Tuesday, 28 August 2018 at 23:27:09 UTC, Nick Sabalausky 
 wrote:

 [...]


 Honestly C++ did OOP somewhat right, because it wasn't forced 
 upon you, but C++ itself has design issues, that I think D has 
 solved very well.

 D does OOP better than C++, but D is still missing some very 
 common OOP patterns.

 See: 
 https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


No, that's not an issue to me, other PLs with OOP behave the same 
way. Problems D has with OOP are more

- not truly virtual destructors (likely a forever problem)
- inherited constructors (should be solved by 
https://github.com/dlang/DIPs/blob/master/DIPs/DIP1004.md)
Aug 30 2018
parent reply bauss <jj_1337 live.dk> writes:
On Thursday, 30 August 2018 at 10:43:24 UTC, Basile B. wrote:

 On Wednesday, 29 August 2018 at 04:53:59 UTC, bauss wrote:

 On Tuesday, 28 August 2018 at 23:27:09 UTC, Nick Sabalausky 
 wrote:

 [...]


 Honestly C++ did OOP somewhat right, because it wasn't forced 
 upon you, but C++ itself has design issues, that I think D has 
 solved very well.

 D does OOP better than C++, but D is still missing some very 
 common OOP patterns.

 See: 
 https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


 No, that's not an issue to me, other PLs with OOP behave the 
 same way. Problems D has with OOP are more

 - not truly virtual destructors (likely a forever problem)
 - inherited constructors (should be solved by 
 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1004.md)


It's an issue with OOP, because the behavior works in literally 
every other OOP language. D is the only one with a different 
behavior and that makes it an issue.

It might be an issue for you, but it certainly is an issue in 
general.

I agree with that those are problems too though.
Aug 30 2018
parent reply Basile B. <b2.temp gmx.com> writes:
On Thursday, 30 August 2018 at 10:57:23 UTC, bauss wrote:

 On Thursday, 30 August 2018 at 10:43:24 UTC, Basile B. wrote:

 On Wednesday, 29 August 2018 at 04:53:59 UTC, bauss wrote:

 On Tuesday, 28 August 2018 at 23:27:09 UTC, Nick Sabalausky 
 wrote:

 [...]


 Honestly C++ did OOP somewhat right, because it wasn't forced 
 upon you, but C++ itself has design issues, that I think D 
 has solved very well.

 D does OOP better than C++, but D is still missing some very 
 common OOP patterns.

 See: 
 https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


 No, that's not an issue to me, other PLs with OOP behave the 
 same way. Problems D has with OOP are more

 - not truly virtual destructors (likely a forever problem)
 - inherited constructors (should be solved by 
 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1004.md)


 It's an issue with OOP, because the behavior works in literally 
 every other OOP language. D is the only one with a different 
 behavior and that makes it an issue.

 It might be an issue for you, but it certainly is an issue in 
 general.

 I agree with that those are problems too though.


Try Delphi, ObjFPC they also do the same as D. `protected` is 
there for what you thing is a bug. it's conform with the module 
system and the protections (or unit instead of module in the 
language i mentioned before).And this is just a detail 
anyway...just use protected.
Aug 30 2018
parent Bauss <jj_1337 live.dk> writes:
On Thursday, 30 August 2018 at 11:28:47 UTC, Basile B. wrote:

 On Thursday, 30 August 2018 at 10:57:23 UTC, bauss wrote:

 On Thursday, 30 August 2018 at 10:43:24 UTC, Basile B. wrote:

 On Wednesday, 29 August 2018 at 04:53:59 UTC, bauss wrote:

 On Tuesday, 28 August 2018 at 23:27:09 UTC, Nick Sabalausky 
 wrote:

 [...]


 Honestly C++ did OOP somewhat right, because it wasn't 
 forced upon you, but C++ itself has design issues, that I 
 think D has solved very well.

 D does OOP better than C++, but D is still missing some very 
 common OOP patterns.

 See: 
 https://forum.dlang.org/thread/tjqxslxfxjgliyziznvk forum.dlang.org


 No, that's not an issue to me, other PLs with OOP behave the 
 same way. Problems D has with OOP are more

 - not truly virtual destructors (likely a forever problem)
 - inherited constructors (should be solved by 
 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1004.md)


 It's an issue with OOP, because the behavior works in 
 literally every other OOP language. D is the only one with a 
 different behavior and that makes it an issue.

 It might be an issue for you, but it certainly is an issue in 
 general.

 I agree with that those are problems too though.


 Try Delphi, ObjFPC they also do the same as D. `protected` is 
 there for what you thing is a bug. it's conform with the module 
 system and the protections (or unit instead of module in the 
 language i mentioned before).And this is just a detail 
 anyway...just use protected.


Protected defeats the purpose of it because.

A inherits B and B inherits C.

A only accepts B to manipulate the field of A and not C.

With protected C can access it. With this fixed to have same 
behavior as other languages then C will not be able to.

D didn’t implement friends because you can access private fields 
within the same module, but it’s not possible in this scenario 
and that’s a bug.

If it shouldn’t be possible then D does need to implement friends.
Aug 30 2018
prev sibling parent "Nick Sabalausky (Abscissa)" <SeeWebsiteToContactMe semitwist.com> writes:
On 08/28/2018 04:39 AM, bauss wrote:

 The following language is a dangerous competitor to D.
 
 https://github.com/joaomilho/Enterprise


Truly a visionary for this Millennial age. The cloud-plans for 
Enterprise Web 3.0 are particularly disruptive. I'm excited just 
imagining the possibilities it will open to bring onboard a significant 
plurality of contractors with upper-tier invoice payment structures.
Aug 28 2018