I happened across this old thread in a search for "mobile app dlang". I got a Chromebook recently and it represents a substantial phase shift in devices for me:

* It's an ARM laptop (Asus Chromebook R13, big.LITTLE 2/2 cores, 4GB memory)
* It's also a tablet convertible
* The main OS is the web browser
* The secondary OS is a Linux desktop(via Crouton)
* The other secondary OS is Android(Play Store support)
* They all run simultaneously. ChromeOS supports this with minor end-user configuration(hit some secret shortcut keys for developer mode, run a shell script, click some boxes).
* It cost under $300 (refurbished) and it's "high end" for the product segment, and feels like it

Which means I have ~three software ecosystems(two if you're feeling uncharitable,  since all of them can do some web browsing) on the same device, all representing different market segments but more-or-less successfully converged. Although some things like clipboard compatibility aren't in the offing, I can switch between them with shortcut keys and share parts of the file system without any virtualization or rebooting. And "high end mobile" performance covers so many applications that as an individual I can only justify trading up for certain heavy workloads(large code-bases, high-end gaming, some media editing and encoding). If I were feeling daring I could also try running Wine, but that's better left to the x86 Chromebooks.

It's gotten me thinking that what we're looking at now is really a fully converged computing environment where monopolistic bottlenecks on software platforms are  eroded, leaving us back in the position of generic device form factors(type and  quantity of I/O, energy efficiency requirements) as the main constraints on the  application. So "mobile" may also cease to be a category of substance at the same time as "desktop" and "Web". We'll just have "front-end"/"client", plus some UI forms to cover different devices.

At least, that's where we're going. But it's not "there" yet except in this particular product line, since Google is forcing the issue in it - and the sales figures do suggest that it's carving up the PC category and invading schools everywhere.

That thought is playing in my head against recent advertising of BetterC - the USP of "give new life to old code" seems like the most straightforward way to address this future, since if we change our set of assumptions away from "new platforms" in the usual sense of a technology shift provoking boil-the-ocean rewrites, but instead to a continual agglomeration of new into old and old into new, with most shifts occurring within the existing stacks instead of without, then leveraging old code by every means possible becomes the most important thing.

Which leads me to a great armchair proposal: D should support Excel spreadsheets ;)

On Thursday, 24 August 2017 at 10:47:07 UTC, James W Hofmann wrote:
> Which leads me to a great armchair proposal: D should support Excel spreadsheets ;)

You say that somewhat in jest but take a look at https://github.com/kaleidicassociates/excel-d

On Thursday, 24 August 2017 at 10:47:07 UTC, James W Hofmann wrote:
> I happened across this old thread in a search for "mobile app dlang". I got a Chromebook recently and it represents a substantial phase shift in devices for me:

Arm has indeed become a more compelling platform, especially with all the SBC that exist today. Nothing more fun as compiling code on a Pi3 and seeing that little monster working like the big boys ( of course slower ).

Unfortunately, not everything works great. Like LDC being version 0.14.0 ( 2014! ) on the Pi3 Debian images. And well, "_Unwind_RaiseException failed with reason code: 2128056904", on a simply compile. Not exactly hopeful.

C works great. C++ same. GoLang version 1.3.3 and later perfect. FreePascal totally useless with "An unhandled exception occurred at $00084234". Its interesting to see what languages work and those that bum out with default debian installations.

So its a mixed bag on ARM development. But people underestimate how fast the ARM platform is evolving regarding speed. The Pi3 has 4 Armv8 A53 cores but you got now systems like Helion X20 with 2 * A72, 4 * A53 and another 4 * A35... Getting to being only 1/4 then a full blown Intel 7600. All that for a 15W max package. And this year we are getting 10nm X30 with more updated cores. Good times...

The PC evolution market in regards to CPU technology has been frankly very dead for the last few years. Small gains each generation but nothing impressive. The only impressing thing has been the AMD Ryzon's that finally pushed 8 cores into consumer hands for a cheap price ( and the thread ripper for 16 for a "reasonable" price, unlike Intel there prices for ages ).

On Thursday, 24 August 2017 at 10:47:07 UTC, James W Hofmann wrote:
> I happened across this old thread in a search for "mobile app dlang". I got a Chromebook recently and it represents a substantial phase shift in devices for me:
>
> * It's an ARM laptop (Asus Chromebook R13, big.LITTLE 2/2 cores, 4GB memory)
> * It's also a tablet convertible
> * The main OS is the web browser
> * The secondary OS is a Linux desktop(via Crouton)
> * The other secondary OS is Android(Play Store support)
> * They all run simultaneously. ChromeOS supports this with minor end-user configuration(hit some secret shortcut keys for developer mode, run a shell script, click some boxes).
> * It cost under $300 (refurbished) and it's "high end" for the product segment, and feels like it
>
> Which means I have ~three software ecosystems(two if you're feeling uncharitable,  since all of them can do some web browsing) on the same device, all representing different market segments but more-or-less successfully converged. Although some things like clipboard compatibility aren't in the offing, I can switch between them with shortcut keys and share parts of the file system without any virtualization or rebooting. And "high end mobile" performance covers so many applications that as an individual I can only justify trading up for certain heavy workloads(large code-bases, high-end gaming, some media editing and encoding). If I were feeling daring I could also try running Wine, but that's better left to the x86 Chromebooks.

I've been using an Android tablet with four ARMv7 cores and 3 GBs of RAM as my only development hardware for almost two years now.  I don't game or edit media, but I've had no problem tweaking and building fairly large codebases like llvm and ldc on the tablet, by using the Termux Android app.  I never had a monster desktop with multiple core i7s and 32 GBs of RAM- my last daily driver was a Win7 ultrabook with a core i5 and 4 GBs of RAM- so it's not that much of a difference, even less if I got something newer like you have.

> It's gotten me thinking that what we're looking at now is really a fully converged computing environment where monopolistic bottlenecks on software platforms are  eroded, leaving us back in the position of generic device form factors(type and  quantity of I/O, energy efficiency requirements) as the main constraints on the  application. So "mobile" may also cease to be a category of substance at the same time as "desktop" and "Web". We'll just have "front-end"/"client", plus some UI forms to cover different devices.

What is actually happening is that mobile is killing off both desktop and web (see second graph in first link):

http://www.asymco.com/2016/11/02/wherefore-art-thou-macintosh/
https://www.usatoday.com/story/tech/2017/04/12/pc-shipments-dip----again/100347930/

I don't know what you mean by front-end/client, but yeah, we'll probably see even more convergence on a few UI frameworks in the coming years.  That won't be the web though.

> At least, that's where we're going. But it's not "there" yet except in this particular product line, since Google is forcing the issue in it - and the sales figures do suggest that it's carving up the PC category and invading schools everywhere.

Another possibility is just using your phone for everything, with a laptop shell like this:

https://sentio.com

As I noted initially, this is built into the Galaxy S8, one of the top-selling smartphones this year.

> That thought is playing in my head against recent advertising of BetterC - the USP of "give new life to old code" seems like the most straightforward way to address this future, since if we change our set of assumptions away from "new platforms" in the usual sense of a technology shift provoking boil-the-ocean rewrites, but instead to a continual agglomeration of new into old and old into new, with most shifts occurring within the existing stacks instead of without, then leveraging old code by every means possible becomes the most important thing.

As others have pointed out, you could use D with C fairly easily for some time now.  You had to be a little careful to initialize the runtime, but that's about it.  This betterC effort is to placate those who can't or won't use the GC and a few other runtime features, even though many of them probably could.

So while it's good that D will make an effort to replace more C code, I'll also point out that many of the problems with software right now come from precisely this incremental approach.  You keep building with mud and straw and eventually it all caves in.  It would be nice if D gives a new lease on life to some ancient codebases, but the real potential with D is to build completely new tech that obsoletes the old stuff.

To some extent, that is what happened with the mobile shift, where nobody uses Wintel, ie x86 CPUs or Windows, on mobile (though Microsoft is trying again with ARM).  Another big shift that seems to be ramping up right now is a move towards voice-driven interaction instead of mouse/keyboard or touch.  The hope is that D's power and flexibility drives new shifts like this, many of which are long overdue because of the stagnation of the last couple decades.

On Thursday, 24 August 2017 at 12:35:08 UTC, Ryion wrote:
> On Thursday, 24 August 2017 at 10:47:07 UTC, James W Hofmann wrote:
>> I happened across this old thread in a search for "mobile app dlang". I got a Chromebook recently and it represents a substantial phase shift in devices for me:
>
> Arm has indeed become a more compelling platform, especially with all the SBC that exist today. Nothing more fun as compiling code on a Pi3 and seeing that little monster working like the big boys ( of course slower ).
>
> Unfortunately, not everything works great. Like LDC being version 0.14.0 ( 2014! ) on the Pi3 Debian images. And well, "_Unwind_RaiseException failed with reason code: 2128056904", on a simply compile. Not exactly hopeful.

Have you tried this more recent build of ldc 1.1.0 (third link in Downloads section at bottom)?

https://github.com/ldc-developers/ldc/releases/tag/v1.1.0

> C works great. C++ same. GoLang version 1.3.3 and later perfect. FreePascal totally useless with "An unhandled exception occurred at $00084234". Its interesting to see what languages work and those that bum out with default debian installations.
>
> So its a mixed bag on ARM development. But people underestimate how fast the ARM platform is evolving regarding speed. The Pi3 has 4 Armv8 A53 cores but you got now systems like Helion X20 with 2 * A72, 4 * A53 and another 4 * A35... Getting to being only 1/4 then a full blown Intel 7600. All that for a 15W max package. And this year we are getting 10nm X30 with more updated cores. Good times...

The ARM chip in the iPad Pro supposedly beats the lower and mid-end mobile Mac x86 CPUs in benchmarks.

> The PC evolution market in regards to CPU technology has been frankly very dead for the last few years. Small gains each generation but nothing impressive. The only impressing thing has been the AMD Ryzon's that finally pushed 8 cores into consumer hands for a cheap price ( and the thread ripper for 16 for a "reasonable" price, unlike Intel there prices for ages ).

More importantly, that core i5 from five years ago is good enough.  You cannot compete on performance improvements anymore, for the vast majority of consumers.  That's why the desktop/laptop PC market is shrinking to only those who need powerful hardware for niches like hardcore gaming, compiling large C++ codebases, or editing 4K video, which is a tiny market compared to mobile.

On 2017-08-24 12:47, James W Hofmann wrote:

> Which leads me to a great armchair proposal: D should support Excel spreadsheets ;)

Not sure what you had in mind but have a look at:

http://forum.dlang.org/post/ubheswgdpafyeybohnyb@forum.dlang.org

-- 
/Jacob Carlborg

On Thursday, 24 August 2017 at 14:28:07 UTC, Joakim wrote:
>> Unfortunately, not everything works great. Like LDC being version 0.14.0 ( 2014! ) on the Pi3 Debian images. And well, "_Unwind_RaiseException failed with reason code: 2128056904", on a simply compile. Not exactly hopeful.
>
> Have you tried this more recent build of ldc 1.1.0 (third link in Downloads section at bottom)?
>
> https://github.com/ldc-developers/ldc/releases/tag/v1.1.0
>

Thanks. I checked the 1.3.0 but there was no ARM build. Did not realize there is one for 1.1.0.

For anybody finding this using google search, simply do the following to install:

> wget https://github.com/ldc-developers/ldc/releases/download/v1.1.0/ldc2-1.1.0-linux-armhf.tar.xz
> sudo tar -C /usr/local -xf ldc2-1.1.0-linux-armhf.tar.xz
> export PATH=$PATH:/usr/local/ldc2-1.1.0-linux-armhf/bin

My code now works correctly again. Doing some benchmarks Apache+PHP vs Go vs D on the Raspberry Pi 3.

n=100000 c=500

Apache: 1488 seconds
Requests per second: 67.20

Go+Gin: 123 seconds
Requests per second: 812.23

D: 149 seconds
Requests per second: 629.46

D is running a simple socket + limited HTTP 1.0/REST framework that i gobbled together. No optimizations. Go is running a complete HTTP/REST framework so it has more overhead.
Apache+PHP5.6 simply suffer beyond belief.

Take in account, the D has only been done on a single core! Where all the others used all 4 cores.

Impressive even if its not apples to apples comparison.