What could be next big thing? Well, I see one easy example - live AI translation (translator will be AI in datacenter), now is manual, but this technology is very close to become real in just nearest years.
748 karma · joined February 15, 2022
And what we see?
- Must admit, some railroads become bankrupt and decades donated from taxes, but not closed, because viable infrastructure; most other suffered from giant wave of Merges&Acquisitions (standard macroeconomic term M&A).
Same wave of M&A happen on telecom market, as I hear from my friends, big business bought small companies, estimated price just on number of clients, and than through all their hardware to landfill (small networks usually built from cheap Chinese SOHO hardware, and instead of routers used PCs) and rebuild all hardware part from scratch, based on telecom-industrial grade hardware.
And really, all modern European transport and telecom infrastructure is from these two waves of huge investments.
Honesty, railways are still moderate profitable (many very significant, like England-France tunnel are unprofitable), and similarly, telecom infrastructure also not much profitable (suburban and rural are in many cases donated), and same problem was with data-centers before AI.
If capital investments into AI will end on current level, this could be considered just second wave of telecom investments - as I said, first wave was huge, but civilization survived and we now actively using fruits of these investments.
If investments into AI will exceed railways level (~5.5x telecom investments), this also will not be end of life but sure need many more profitable AI products than we have now.
So, even if will be achieved progress just now, I think in predictable future this will be constant dead-end.
Example, ancient natural asphalt, which literally surfaced at Red sea.
So, probably natural material, not always exactly known how appear, but fortunately existed and used by ancient people.
I only cannot agree that all lost technologies are not that we might truly care about. As example, Roman concrete could be really valuable in modern world, as current concrete just is being destroyed with time, and this is very serious problem, because could be dangerous for constructions like large dams and bridges; also, need some solution for long term burial of radioactive trash.
How to save such info, very interest question and not easy. Possible example could be some sort of long term independent shelter, under Moon surface, where could store digital archives with information.
Nope.
It's 2025 outside.
Google "Visual Scripting", "Unreal Blueprints". It is now possible to make game literally without writing any STRING of code.
Second, with development of AI more and more appearing "no-code" solutions, in some cases even capable deliver app from blueprint painted with pencil on paper.
At beginning, Internet used network classes, because of hardware limitations (later switched to address blocks). And even in 1990s still existed very old hardware, only could use class addresses.
What classes mean, existed early very large organizations, got more addresses than they could use. And even happen few cases, when such organizations lost rights for these addresses.
And these unlucky organizations was some big whales, like IBM or ATT/Bell or Sun.
And once invented solution - state some big enough network as not allocated to use under NAT (or when network is not connected to Internet). So, departments of big organizations could use TCP/IP stack in their networks, even with old hardware, but don't need to contact Internet officials to got real internet addresses.
192.168 was just first C-class network prefix, was not assigned at the moment (or just released).
Later, to list of unassigned added 172.16/12 network.
And in GD, code have much less importance than in other fields.
As example, I once meet amateur of RC-planes, and looking on his setup I asked, why his electronics is so simple, as I understand, he could make much more sophisticated things.
Answer was: "here, I want to be airplane designer, not electronics designer, so I make plane highest priority, and sure, when you will make your plane, you could make electronics priority".
Again, this is not philosophy, this is real thing - in GD language is the least important thing for happiness, in best case it is small obstacle at the way to create game, so the best language could be no language at all.
If you could suggest some way, how it is possible to do platform where programming language hidden deep under the hood, so people just don't use language at all, but things are done, this will be very constructive talk.
So, technically, high-level ECMA-6 language transpiled (more traditional word translated) to ordinary Javascript, and supplied file with structures, similar ideologically to C symbols tables, and within browser debugger (Chrome work) you could see not target JS but sources and debug on high level.
And when your code become mature, you just remove symbols tables and as usual, target optimized code become very much like obfuscated, and you could provide it as closed source.
So, as summary - must have all from list:
1. high-level language translator (may be into assembler, may be into some lover level language, as with ECMA-6 and JS)
2. some sort of debug support (as mentioned symbols tables)
3. good enough debugger, as much close to client platform as possible (Chrome is good example).
Why so, because, at digital games dawn, hardware was too limited, just hardware limitations prohibited large projects; when appeared big networking games, complexity shifted to server-side, so for them subject irrelevant; now possible big games without networking, but high-definition multimedia costs prohibitive.
So, for subject only relevant small games, with small codebase, so they even avoid text programming at all and many people switched to so named Visual Scripting (google).
I've taken part at some large apps built inside one company in extremely short time. And no, in my list only more or less adequate platforms - Perl, MS VBA on web.
And I've countless times just rebuilt some large systems from sources - FFMPEG, Unreal 4 environment, what interest, whole FreeBSD 4.x with BSD environment including XWindow is smaller than U4.
And what was really big pain, I tried to work with NASA OpenMCT, and because it was based on Javasript technologies, I spent huge amount of time to figure out, where end server-side and where begin client-side. I think you understand this is important, because each part debugged with very different instruments and techniques.
And what I must say there, games are very different in scale.
- Sure, exist very large games (named AAAA, like cinema movies, and have so huge download size, as for example new Stalker, that my friends working in telecom complained, it was like huge DOS attack when game came out). And what also interest, AAAA games tend to make their own custom game engine, yes, each game with own game engine, because for them easier to figure out in their own code than to learn ready game engines.
Also exist industry of game studios, medium businesses, but they tend to be much like big businesses just without resources to make own engine.
And also exist huge industry of independent -games (i will use indi- name), which have very small amount of code, because of tiny budgets or just "no-budget" work, in many cases literally made by one person, who making pictures, code and sound himself. And in reality I know very few cases, where indi- makes his own engine, but most others are slightly modified already known game mechanics.
What important - big business will not use subject code, nearly guaranteed, because they have very specific demands about maintenance, to fulfill them need at least medium company; there is more probability to reach medium business clients, they are trying to be "like a big boys", but in most cases possible to achieve some understanding; and the most probability is to reach indi- developers.
So, what we talking about now, is mostly about indi- developers, one-person sized commands, and it is very god if they will just use C-like languages, but you cannot account for them to use fp paradigm.
I cannot at the moment give estimate of distribution of game sizes, but now tend to appear more indi- developers with small games (and sure, using some made by other people.
For Closure, I just confused it with Elixir.
Unfortunately, I see very familiar things from Perl world - many people made really interest things alone, but for some reason, they don't organize to make one direction really on par with commercial platforms (even when with current technologies could make efficient distributed governance, and even could make significant sells for sustainable development). I mean, people disperse resources, making many good small things, but most Open Source software recessing or even in crisis without moving ahead.
I've seen JVM, BEAM, CLR at field with heavy load, they all have significant drawbacks, but from my opinion, CLR ecosystem developing faster than other mentioned.
All looks like recession, where measured changes within measurement error (~2..3 percents very usual for such things).
Even very much looks like typical market without much grow or shrink - sales of premium brands (Audi, Benz) suffered less than mass-market (Toyota), but again, all changes within measurement error.
Need more data to make serious conclusions about possible crash.
Only could say one conclusion - Chinese always made strange things, in this case constantly grow production capacity without demand. I don't understand where they planned to sell twice as now number of machines, except if planned to supply some big war.
─────────────
/ \
/ \
/ \
/ \
│ │
│ circle of power │
│ │
│ │
│ │
\ /
\ /
\ /
\ /
─────────────I just don't see thank you. Formally your answers are not hateful, but you may say thanks for info I provided, as I see you was not aware before.
- Tried, and it really work.
Exist two approaches to overcome GC problem, but if somebody will again minus my comment I will not bother to find links in my records.
1. Here on HN mentioned GC-free fp platform.
2. Few years ago appeared GC algorithm with linear complexity (sure, with limitations, but good enough for example for 16-bit consoles level games).
Unfortunately, haters minusing comments, but don't add anything valuable, and author was not mentioned these problems.
Other conclusion, looks like you are hater, minusing my comments just because you don't agree and don't accept any views except your own.
Read-ahead (superscalar) becomes typical from Pentium and similar class CPUs; even specialized data types gaining some usage (AVX-512, FP-16/FP-8); but for hardware GC I don't know any widely used examples.
Unfortunately, this is very long known dead-end, because very few programs written evidence-based, but most just begin their life with first production release, and on some platforms (JVM), more than 90% of developer time spend to refactoring and maintenance of existing code, and many people don't know anything else.
So, templates are not enough to break through this wall, need infrastructure of libraries and debuggers, and may be macros, etc, designed specifically for fp and be at least on par with their imperative counterparts.
This is semi-Truth.
Modern off the shelf Microcomputers nearly all imperative, because marketing won, but when world was under Mainframes (nearly up to 1980), existed many examples FP-optimized architectures or high-level architectures, even some of them was commercially successful (Lisp computers and some high-level mainframes).
Also, most developers don't deal with naked hardware, but working with libraries of structures and libraries of high level algorithms, this named abstraction layer. Just some existing abstraction layers are less abstract and other are more abstract. As example, in Windows (and in most UNIXes) file abstraction is very simple and just imperative, but in MacOS it is OOP (derived from NEXTStep as I hear, based on ObjectiveC), and also exist some other OSes based on OOP languages, like BeOS, even when MacOS/BeOS are now running on same x86 hardware.
So possible just run inside higher level VM.
And mathematics is not prohibiting FP-machine, they could have very effective implementations with modern math.
What really problem, except of Prolog, I don't hear about high-level debuggers for fp languages, so writing on for example Ocaml, you once end up looking on fp structures with old C debugger, which sure don't see fp structures.
I love functional paradigm, but sometimes fp lovers, looks like evangelists of Blockchain or LLMs - not bad things, but all have their limits, and not very useful without powerful support of large library of fp structures and debugging programs. So, trying to use fp, you dive into abyss, writing with fp, but debugging with low level C debugger.
BTW, as I know, OcaML, flagship of fp, just don't have graphics debugger, so people used to write on Haskell using old classic REPL technology, than, thanks to syntax similarity, most code just compile on OcaML without additional moves.
This may become gamechanger, as it could be very fast, but high level abstraction, so people don't need to dive into machine level, and could work on high level.
Once one boy said me "this is Mac, on it things look different" and shown me just ordinary MS Office (for Mac) files in just standard utility. And I seen really other world - even on old MacOS (7..something), Office files was not just hexadecimal, but I easily see structure. Unfortunately, that's time I have not enough education in CS to understand how structures work, but some things was obvious. These was just some things partially implemented on ObjectiveC (too small objective part and too large C part), but any way it become significant shake of my world.
Unfortunately, in Linux I constantly see the same as in DOS - mostly just hexadecimal dumps, no structure, so developers don't have motivation to use structured data, as it will not help them on build and maintenance.
From what I see, looking promising, to discontinue UNIX systems (based on C, and yes, Windows is also favor of UNIX, as NT was made directly on foundations of VMS from Digital), and switch to something more high-level, like OpenStep (with high usage of SmallTalk), or at least BeOS (based on C++).
Sure, would be better to use Prolog based OS, when one will appear, or may somebody will create OS based on OcaML (Haskell, Rust).
What I see problem for gamedev, in many cases they need very high performance, and when nearly all target (current) OSs are just C-machines, it is very much like discover epic huge wall, when need to switch from OcaML level to C to get additional few FPS.
So most people choose easy way, they learn just primitive subset of C++ and work with it.
https://en.wikipedia.org/wiki/Comparison_of_operating_system...
Unfortunately, just as I suspected, this project use OpenGL (nearly all implementations are C++), and C++ collision/physics engine.
So, looks like, in this project, Clojure is used just as high level script to orchestrate all C++ parts, may be later we hear about some game scripting, but for simulators they are not as need as for example for RPGs.
I agree, Clojure is better than C++ for orchestrate, but I have seen so tiny number of art persons familiar with functional paradigm, so this looks like beautiful dead end.
Again, this is really beautiful and respectful achievement for author, but people I seen working in gamedev will not accept such approach.
I have significant experience on modelling physical world (mostly CFD, but also gamedev - with realistic rigid body collisions and friction).
I admit, exists domain (spectrum of parameters), where CFD and game physics working just well; exists predictable domain (on borders of well working domain), where CFD and game physics working good enough but could show strange things, and exists domain, where you will see lot of bugs.
And, current computing power is so much, that even on small business level (just median gamer desktop), we could save on more than 90% real-world tests with simulations in well working domain (and just avoid use cases in unreliable domains).
So I think, most question is just conservative bosses and investors, who don't believe to engineers and don't understand how to do checks (and tuning) of simulations with real world tests, and what reliable domain is.
Text really have lot of degrees of freedom, but depends on language, and even more on type of alphabet - modern English with phonetic alphabet is worst choice, because it is simplest, nearly nobody use second-third hidden meaning (I hear about 2-3 to 5-6 meanings depending on source); hieroglyphic languages are much more information rich (10-22 meanings); and what is interest, phonetic languages in totalitarian countries (like Russian) are also much more rich (8-12 meanings), because they used to hide few meanings from government to avoid punishment.
Language difference (more dimensions) could be explanation of current achievements of China, superior to Western, and it could also be hint, on how to boost Western achievements - I mean, use more scientists from Eastern Europe and give more attention to Eastern European languages.
For 3D robots, I see only one way - computational simulated environment.
And must say, "DOS like interface", I think too kind, as really current LLM interface, more like teletype :))))