Posts by Steve Channell 113 posts • joined 19 Aug 2014
Map/Reduce in general and Hadoop in particular was a good start for data-centric computing for those that could not budget for Teredata scale kit - somewhat unfair, but 30yr behind the leading edge.
There'll always be a place for cheap/simple tools like Hadoop in the Data Grid, the problem is that better tools are now cheaper, and distributed file-systens are moving into hardware
While static analysis is a good thing, the place to deploy it is in the build server prior to regression testing.. like https://www.sonarqube.org/ does.
When the code is product-ready they'll have also addressed the tricky problems of identifying the "error", line providing diagnostic error messages and an ignore pragma for cases where it's a deliberate optimisation.
When they say "other languages", they mean Kotlin and Scala..
but the core Microsoft Executive is likely to be open-sourced for hypervisors to be loaded from firmware like UEFI that runs all operating systems as a guest.. without the wider kernel, the microkernel will revert to the original design.
The "S" in WSL is still a subsystem, but one where the process management is handled within the subsystem and not translated to Win32 calls.
Skype started out as an offshoot from peer-to-peer file-sharing app that was widely used to pirate music: Adding voice calls made it impossible for music companies to detect that music was being shared rather than person to person communications, and therefore somewhat protected from prosecution. To the surprise of the developers the voice function was vastly more popular that the file sharing service putting pressure on the super-nodes that relayed traffic between computers that could not connect directly on local networks because of firewalls and NAT: they had a choice between grow and or die and found a willing buyer in ebay.
Skype was fine for point-to-point connections, but video conferencing was not it forte, and suffered reliability problems scaling the super-nodes that were not designed for load balancing: Microsoft put quite a lot of investment into scaling the super-node infrastructure but dropped P2P in an attempt to get telco on-side for Windows Phone.
After the Window-8 disaster it really became a retail brand for corporate Lync Server: it is somewhat ironic that a cloud native technology was pushed into the arms of office collaboration and kept away from Azure where its UDP datagram baggage could overload host routers.
Until recently open-access videoconferencing was niche: Zoom did not defect Microsoft, AWS did by scaling the Zoom infrastructure, but politics was the real killer
.net support for struct (value types) means it can natively shape blocks of memory for GPGU execution, Half is good for GPU shader code, for ML or execution on GeForce GPU.
Next addition will be full GPU integration like the unsuccessful C++ AMP
http://www.ilgpu.net/
https://docs.microsoft.com/en-us/dotnet/api/system.span-1?view=netcore-3.1
Odd to mention Netezza and not DATAllegro which became SQL/Server Parallel Data Warehouse.
The power and scale of Teredata at its peak can now be replaced with with a large workstation. While traditional RDBMS laugh at the parsing delays of Hadoop, that does not apply to column-store schema which match well with object-store at the physical level
I once read an article in BYTE (decades ago) that described a C function that took void* parameters as a slut-interface.. there has always been terminology that was wrong.
Kill and spawn always seemed a bit juvenile but banning "abort" is plain stupid (abortion is medically termination because we now know that a sperm is not a seed)..will signal terminate be banned?
"class" is elitist, but we'll save that PK change for April-1st
It is not unreasonable to believe that a G7 country might be able to force a tech company to treat a Covid app like a music app and run in the background. The fact Apple was bold enough to refuse is telling - setting itself up as a supranational organisation is is a precident that will not go unanswered - expect to see their root certificates buster within a year.
The "by winter" announcement probably Means they're going to go the Telco route (like South Korea and Norway) and use mast triangulation for proximity (Bluetooth works through walls, so not foolproof).
Another option is to use fitness trackers, but that's a longer-term option but will be a waste of money if a vaccine works - expect to see talk of revived MS Band tracker popping up.
The Underlying technology behind horizon was reposte a distributed message store with asynchronous replication in batches between centres and branches (originally ISDN) with UDP between computers in a branch. Like TIBCO rendezvous, all messages have a sequence number, and dropped messages are re-transmited - not especially different to a distributed ledger like bitcoin - but quicker
It's sloppy reporting to imply that data might be hacked by some delphic oracle, rather than bidirectional replication. Originally benefit payment were sent pre-authorised to a number of branches so that payments would not be delayed by network latency (pre-authorisation being cancelled during replication).
Cash Account summaries were compiled in branch at the end of and sent (by paper post) and electronically.
Architecturally the cash account should have been produced by summarising all transactions in the host database because the branch file was a system (and commerical) boundary, but.because of the branch paper report calculation was distributed.
People weren't prosecuted because of the system failure, they were prosecuted because the political imperative to justify the cost of the system
When Netezza was formed the single novation was using programable FPGA rather than the ASIC of Y/BY net in the original. Whilst faster than DATAllegro and cheaper than Teradata seems like a good niche, it can't compete with free in Hadoop or the increasing capability of NUMA conventional big boxes
This post has been deleted by a moderator
The C++ extensions that Microsoft developed for parallel C++ kernels that run either on a CPU or GPU through HLSL made parallel programming much easier than OpenCL or CUBA largely through the restrict(amp) compiler directive.
The downside to C++AMP was the runtime need to use DirectX and WARP engine (for n-core CPU execution).. porting DirectX means that the C++ AMP Clang extension developed by AMD can be 100% compatible with the Windows version.
While it is tempting to say Meh, the ability to debug a kernel on a CPU is a vey valuable.
When Teradata Launched over thirty years ago the limiting factor was IO bandwidth, which it addressed with a custom network fabric that ordered responses across the MPP achieving high throughput without overloading the 386 processors. Data was distributed using a proprietary hash that was little different to standard key hashing (case insensitive and tweaked for common text). Compared to Hadoop it was well ahead of time with TQL decomposed into a series of map/reduce distribution operations. Performance of "SELECT DISTINCT ..." was slower than "SELECT ... GROUP BY..." because even in a DBC/1012 grouping was quicker to perform on AMP than through the Y/BY-Net ASIC.
Strategically Teradata missed the boat more than twenty years ago when Oracle (EXAData), Microsoft (DataAlegro/PDW/Synapse) and IBM (Netezza) upscaled their footprint - their choice was to milk the Niche status and stickiness of an established appliance vendor and provide (and fail to provide) an up-sale channel for TopEnd TP monitory to complement the intrenched NCR position on POS/ATM.
Architecturally Teradata Operating System (TOS) (later re-hosted on NCR UNIX) is a Pascal p-machine, so porting to Java should not be a major problem, the challenge is how to go from a high-margin support/training model to an open-source provider without being cannibalised.. evidence from MapR is that they'll fail.
The problem will most likely be an array in working storage, which are defined like
05 claim OCCURS 1000 TIMES.
Fixed array sizes are not as daft as they seem, but were a mechanism to enable the scheduler to avoid over committing resources while scheduling jobs. For S/370 it was also used for 20-bit, 31-bit (XA), 64-bit (ESA/z) compilers to fit into smaller memory regions
As with any engineering problem, it is not the one-line code change that takes the effort, but the elaboration of dependancies and testing that takes the effort. It might not be feasible withing the constraint of compiler, os, platform. That one-line change can grow into a quarterly upgrade.
The "solution" is probably to run the batch multiple times, or force people to wait longer.. which brings us to the politics: "don't blame me, blame the IT" with the new twist "blame yourself/compatriots for not volunteering"
Two of the weaknesses of the Java platform are [1] the poor support provided through JNI to integrate Java applications with native binary libaries [2] Java practictioner view that all applications should be recoded in Java to avoid interoperability problems. While it is generally accepted that the Microsoft extension to Java for COM integration was an attempt to make Java applications Windows specific; it is also true that copyright of COM was transfered to X/Open to remove licence issues. It is not unreasonable to conclude that the use if COM (on windows) and XPCOM (on Linux/ *ix) was a genuine attempt to provide an object based application binary interface.
Over the twenty years since Sun committed to integrating XP/COM ABI into the JVM, we have not seen the wholesale re-implemntation of everything in Java, but we have seen many inovations with FPGA, GPGPU, SDN, ML, AI etc that demostrate that there will always be a need for interop with Binary code.
Project Panama took like it has incorporated the lessons (failings) of Object-RPC, but the absents of "struct" (value-types) is still an ommision that makes this task more difficult. Comparing Project Panama with the CLR P/Invoke leaves me wondering whether this decades old problem will ever be solved..
It's ironic that one of the big impacts of Java has been the regression to TCP/IP Sockets for interop, and IDL (e.g. protobuf/gRPC) for message formatting.
Visual Basic was always an odd cludge, but back in the day you could write VBA in Excel, export the model to VB6 and compile.. and for performance change classes from VB6 to C++ without changing the COM interface.. VB.net was **not** Visual basic (array offset changed from 1 to 0) - a completely new language that begged the question "why".
supporting a VB.net to C# transalater would be more useful to those foolish enough to build apps in VB. They'd be better spending their time on C++/CLI which is best language for native interop.
I think they've noticed that RedHat Enterprise license with support is more expensive than Windows Server, but customers still buy it because it is cheaper than employing kernel engineers.
Powershell needs to be open-sourced to make it into Linux distributions for Docker and K8 support
I like XAML as a UI markup, and WPF Everywhere promised so much, but failed to be surficiently better than HTML5 to justify the deployment costs. With Visual Studio Code being built on Electron (chromium runtime), it's clear that a cross platform XAML needs to collaborate with W3C and Google and be fully open source.
I'm not sure Microsoft is ready for the challenge.
Until then WinUI is PR
Microsoft will have seen what has happened with the open core of MacOS (Darwin) and seen that an open core does not threaten the Windows franchise. The motive would be to provide a core microkernel infrastructure that can be preloaded on cloud infrastructure to load Win32 and Linux subsystems. This core would be good for a variety of Software-Defined network and storage appliances.
The reason it hasn't happened yet is more to do with the maturity of the Linux subsystem WSL2 than to do with license or commercial considerations.
In one respect WebAssembly is just the latest incarnation of platform-independent environments that started with UCSD p-system followed by OSF ANDF, JVM, CLR and PNaCL, but standardized and matched with a large browser providing a runtime environment.
Change the runtime to stripped-down Fuchsia like OS with little more than network stack + Kerberos and you have an ideal environment for micro-services
Architecturally WebAssembly is a code-verification sandbox with a controlled API to a runtime: if it works well in a browser, it’ll be an ideal platform for microservices where a different runtime is provided. The challenge on the server-side will be providing a distributed identity-verification runtime to avoid spoofing
Stopping sand time is a function of speed, the only way to avoid collision is go slower when objects can enter your stop zone. Road trains on motorways would be safe about 100 if the lead car is an expert, 20 in urban areas is safe if not following another car.
Urban slow is fine if you can use the time for work/leisure.. and solves the problem of your hire car driving itself to a charging point.
The Tesla version is a cop-out.. pandering to the rich
Alas Java does not have Value Types (struct), properties or tail-call optimisation so not everything can convert + you'd have to choose which broken implementation of DateTime to map to. Going the other way (Java -> .NET) was done years ago with IKVM, but you need to be careful of the broken RMI implementation.
It's amazing how utterly misguided the whole autonomous car business currently is.. driven by completely the wrong use-cases
Instead of trying to be just like a regular car, actual autonomous will drive much slower on normal roads, with the focus being on productive use of time rather than reduced time. Smooth, but slower vehicles will allow people to work, watch a film, or sleep whilst in the pod.. much like a commuter train.
Microsoft will not have failed to notice that open-source Darwin has had no impact on MacOS/iOS sales.
There is a big motive to open-source NT Executive with Hyper-V before the disapearance of the final chance to displace VMWare,KVM,Zen as the default hypervisor for new servers
Aside from the obvious issue that Edge is a also-ran in the browser world, and web-developers are not developing for it, the big change driving this is mature WebAssembly support built into Chromium. PNaCl was Googles project for downloadable native code and forms the basis of WebAssembly binary modules.
Microsoft took the LLVM support in Mono (.NET clone) to enable .NET code in the browser though the Blazer project.. but only works well on Chromium - they use Chromium internally for Blazer debugging. Microsoft will be adding code for debug integration.
Before we go all Snowdon about mass surveillance, it is worth remembering that the terrorists that attacked Paris originated in Brussels, where the security services are useless (much like everything run in that City).. and British Intelligence is the only such service in Europe not tarnished by association with the Gestapo or KGB.
If they happen to pick up on the wittering of Politicians... all well and good, somebody should have an idea of what is going to happen...
This is much more like SWIG than Thrift because it s an interface generator, not an RPC mechanism.
inferring that that std::vector<T> can be translated to Systems::Collections::Generic::List<T> is usefull, but only really an advantage if it avoid copying when passed into another function that expects a std::vector<T>
A number of years ago Teradata UK took delivery of a shinny new NCR massively parallel database computer, and were very keen to demonstrate everything about the new host.
One salesperson hit on the idea of pulling one of the fans out to demonstrate the emebeded systems management and the fan speed up.
Unfortunately the hapless salesperson triggered a manufacturing investigation back in the US that eventually lead to a team of engineers being dispatched to site.. where they scratched their heads to understand why the host fans kept failing.. until the hapless salesperson did his party piece
Galileo should never have been created in the first place: There are two faults with GPS (coverage for accuracy, US right to switch it off or encrypt it).. which could have been addressed with funding contribution and contract.
Space is outside of the realm of Earth laws.. if the UK is locked out through decision to leave the EU, a price can be negotiated on the scrap value.. It is a question of the inconvenience price for recovering them
JIT is older than Java by a couple of decades thanks to Pascal p-code, including Microsoft's Pascal and COBOL runtimes. The new technique of deployment ngen is closer to the OSF ANDF (as is LLVM).
Performance test of .net core CLR compared to Java show it spanking Java..
Functional languages always suffered from the need for larger memory for immutability and all the recursive evaluation, before tail-call-optimisation was properly implemented (JAVA is still a work in progress in this perspective). It is only now that immutability adds more value (through parallelism) than the cost of memory offsets - this is especially so with GPGPU.
If you needed to know how many people are in a queue, imperatively you could stop people joining or leaving - and count them, but that breaks down when people join and leave long queues with contention. Functionally you’d ask the people to add 1 to the number the person behind them had (and 1 it there was nobody) - scale is not an issue and no contention: The imperative approach is always simpler when you don’t really understand the problem
https://www.theregister.co.uk/2018/07/25/google_edge_tpu_chip
It is kinda pleasing when Google looks at your comments, and goes "yeh, I think he might have a point"
A year ago it was tech-porn, now it is developing into something that can really help the world - hopefull CCTV face recognition was not the use-case that tipped them into be open.
Checking in code at the end of the build pipeline is needed for continuous deployment where a test session will be provisioned with a list of TFS tasks (you kinda know where there this is heading) and a VM pre-provisioned with the software that has changed.
When the test pipeline evolves to include multiple stages and/or parallel streams, the binaries need to be versioned in he build/test pipeline as well.
All the talk of running the a soft CPU will be designed to avoid the problems of Itanic which pushed all the parallel logic into compiler but never envisioned multi-core processors that make parallel execution quicker with OS threads than the explicit parallel instructions. Once vendors eventually got hold of silicon and compiler kits it was too late to fix the design flaws in the EPIC design.
Borrowing the GPGPU paradigm of small kernels of code that can be executed in parallel seems like a better approach and Operating systems seem a very good test because each SYSCALL is designed to be atomic.
if it can me made to run effectively, it should provide breathtaking performance
The Register - Independent news and views for the tech community. Part of Situation Publishing
Biting the hand that feeds IT © 1998–2020
