Pl sql developer 11.0.3 keygen

-------- THE ECSOFT/2 WEEKLY NEWSLETTER FOR OS2VOICE -------------------------
Find in this digest all the records created or updated in the last week on the eCSoft/2 site https://ecsoft2.org.
If you find something wrong and you want to report it, or if you want to contribute updating or translating to your language the records, or if just you want to write us, visit our Contact page https://ecsoft2.org/contact or drop us an email at ecsoft2 [dot] orggmail [dot] com
This is a special edition of the eCSoft/2 newsletter created for OS2 Voice.
NEW:
====

• Agena 2.15.1 https://ecsoft2.org/agena
  Agena is an easy-to-learn procedural programming language suited for
  everyday usage.
  
  • FreeRDP Client for OS/2 20190531 https://ecsoft2.org/freerdp-client-os2
  A FreeRDP port for OS/2, eComStation and ArcaOS. FreeRDP is a client for
  Remote Desktop Protocol (RDP), used in a number of Microsoft Windows
  operation systems. * QSINIT 30052019 https://ecsoft2.org/qsinit
  QSINIT is a replacement of OS2LDR created from scratch. * DVD/CD Toys 1.07.00 https://ecsoft2.org/dvdcd-toys
  CD/DVD Toys is a set of utilities to burn CD and DVD disks (Blu-Ray,
  HD-DVD). The utilities support creation and burning of ISO-images.
  

UPDATED:
========

• PMView Pro 3.81 https://ecsoft2.org/pmview-pro
  This is a very fast bitmap viewer for files in JPEG, GIF, PNG, TIFF, Photo
  CD, etc. More than 40 different formats can be read and more than 30 can
  be saved.
  
  • Iron Spring PL/I 0.9.10a https://ecsoft2.org/iron-spring-pli
  Compiler for the PL/I programming language, although it is currently
  missing some features. PL/I is a powerful programming language suitable
  for a wide range of problems. * Apache 2.2.34 https://ecsoft2.org/apache
  The best web server in the world! Now with native OS/2 multi-threading
  support! * Clip 0.1 https://ecsoft2.org/clip
  Clip, a command line clipboard handler. * Qpdfview 0.4.17b5-1 https://ecsoft2.org/qpdfview
  Qpdfview is a tabbed PDF viewer. Program developed using the Qt4 framework
  qt4-application-ui-framework. * Dos2Unix 7.3.4 https://ecsoft2.org/dos2unix
  Convert text files with DOS or Mac line breaks to Unix line breaks and
  vice versa. * Libreria EBML 1.3.0 https://ecsoft2.org/ebml-library
  LibEBML is a C++ libary to parse EBML files.
  EBML, or Extensible Binary Meta-Language, is a simple XML like binary
  language for describing data in structured style. * QupZilla 1.8.9 https://ecsoft2.org/qupzilla
  QupZilla is a new and one of many Qt WebKit Browsers available. In
  addition to standard features, QupZilla offers: * Stunnel 5.50 https://ecsoft2.org/stunnel
  Stunnel is a program that allows you to encrypt arbitrary TCP connections
  inside SSL (Secure Sockets Layer). * CMake 3.7.0 https://ecsoft2.org/cmake
  CMake is a cross-platform, open-source build system.
  CMake is a family of tools designed to build, test and package software. * PHP 5.4.45 https://ecsoft2.org/php
  PHP is a widely-used general-purpose scripting language that is especially
  suited for Web development and can be embedded into HTML. * Tor 0.4.0.5 https://ecsoft2.org/tor
  Tor is free software and an open network that helps you defend against
  traffic analysis, a form of network surveillance that threatens personal
  freedom and privacy, con * WPA Supplicant 2.7GA https://ecsoft2.org/wpa-supplicant
  This is a backend component for controlling the wireless networking
  connection. Wireless Lan Monitor wireless-lan-monitor component. * MySQL 5.5.58 https://ecsoft2.org/mysql
  The MySQL database server is the world's most widely used open source
  database. * SmartSVN 7.0.2 https://ecsoft2.org/smartsvn
  Java based GUI for Subversion (SVN) subversion-svn. Free limited version.
  Latest version running on OS/2 is ver. 7.07. * Nice-OS/2 Enhancer 5.7.1 https://ecsoft2.org/nice-os2-enhancer
  The Nice-OS/2 Enhancer adds new features to the OS/2 operating system.
  Using this application you will be able: * Ddrescue 1.24 https://ecsoft2.org/ddrescue
  Ddrescue is a data recovery tool. * Netlabs GCC 8.3.0 & 3.3.5 (CSD6) https://ecsoft2.org/netlabs-gcc
  Ports of GNU GCC 3.x and 4.x, which ensure 100% compatibility with ANSI
  C/C++. * eCUPS 2.1.3 https://ecsoft2.org/ecups
  The eCUPS project is intended to create a seamless integration of CUPS
  

https://www.cups.org/ into OS/2 base Operating Systems, to sub

• WarpIN 1.0.22 https://ecsoft2.org/warpin
  WarpIN is intended to become the new general-purpose installer for OS/2 to
  overcome the current lack of a both flexible and user-friendly installer.
  
• Simple DirectMedia Layer 2.0.4 & 1.2.15
  

https://ecsoft2.org/simple-directmedia-layer
Simple DirectMedia Layer is a cross-platform multimedia library designed
to provide low level access to audio, keyboard, mouse, joystick, 3D
hardware via OpenGL, and 2D video framebuffer.

• 32bit Linux ext2 file system driver (EXT2 IFS) 2.40

https://ecsoft2.org/32bit-linux-ext2-file-system-driver-ext2-ifs
This is an old driver for the Linux ext2 file system taken from kernels
2.0.x.

• PostgreSQL Server 9.0.6 https://ecsoft2.org/postgresql-server
  A powerful, /open source/ relational database system.
  
• Vi Improved (VIM) 7.0 https://ecsoft2.org/vi-improved-vim
  Vim is an almost compatible version of the UNIX editor Vi. Many new
  features have been added.
  
• SeaMonkey 2.42.9esr & 1.1.19 https://ecsoft2.org/seamonkey
  SeaMonkey is a community effort to deliver an high production-quality
  releases of web browser code derived from "Mozilla Application Suite". The
  program includes the email client.
  
• RXU Library 1.a.0 https://ecsoft2.org/rxu-library
  RXU v1.a, rich set of Rexx functions for OS/2 API!
  
• Thunderbird 45.8.0 https://ecsoft2.org/thunderbird
  Mozilla Thunderbird is a redesign of the Mozilla mail component, with
  several new features and improvements to make your mail and news
  experience better.
  
• 3D Launch Pad 20190326 https://ecsoft2.org/3d-launch-pad
  Launch Pad is a WPS objects launcher for PMShell with support for PNG
  icons.
  
• GSView 5.0 https://ecsoft2.org/gsview
  Graphical interface for Ghostscript ghostscript. Available in several
  languages. Port by different authors.
  
• Adobe Acrobat Reader 5.1 https://ecsoft2.org/adobe-acrobat-reader
  Acrobat Reader, known
  
• Undot 08032012 https://ecsoft2.org/undot
  Undot.cmd is a Rexx procedure to replace one or more dots, commas, spaces,
  brackets and braces in filenames by an underscore character, except the
  last dot: the
  
• BIEW 5.6.4 https://ecsoft2.org/biew
  BIEW (Binary vIEW) is a free, portable, advanced file viewer with built-in
  editor for binary, hexadecimal and disassembler modes.
  
• DjView & DjVuLibre 4.10.6 & 3.5.27 https://ecsoft2.org/djview-djvulibre
  Standalone viewer for DjVu files. Features include navigating documents,
  zooming and panning page images, producing and displaying thumbnails.
  
• Links 2.19 https://ecsoft2.org/links
  A text-mode web browser, which is able to correctly display tables and
  frames, and to render correctly most pages, even if they include several
  graphical elements.
  
• Renzoku Playe2 0.9.9 https://ecsoft2.org/renzoku-player2
  A simple GUI front-end in Rexx language for Mplayer mplayer, KMovie
  Player k-movie-playerand
  
• jEdit 5.1.0 mpg123-audiocenter
  A mature programmer's text editor expandable with tons of plugins.
  
• K Movie Player File Selector 1.0
  

https://ecsoft2.org/k-movie-player-file-selector
Rexx front-end for K Movie Player.

• Nutrition Database 5.5r2 https://ecsoft2.org/nutrition-database
  Nutrition Database, an OS/2 port of a nutritional database for Unix.
  
• Data Transport Agent (DTA) https://ecsoft2.org/data-transport-agent-dta
  This is a beta release of the new Data Transport Agent (DTA) for
  eComStation.
  
• MikMod & MikMODPM 3.3.11.1 & 3.2.8 https://ecsoft2.org/mikmod-mikmodpm
  An OS/2 PM & Text-Mode MOD Player using the MikMod Library. The MikMod
  Library is a portable sound library for Unix and other systems.
  
• Megadesk (Desktop expander) 2.24
  

https://ecsoft2.org/megadesk-desktop-expander
Megadesk is a virtual desktop overview which allows you to expand the area
for your PM windows, creating many "rooms" in which to group running PM
applications.

• Supporto per webcam USB 1.1

https://ecsoft2.org/usb-webcam-support-programs-and-drivers
USB WebCam device drivers and control programs.

• Graham Utilities 2.1 https://ecsoft2.org/graham-utilities
  The Graham Utilities for OS/2 are the largest, most comprehensive suite of
  disk, file and general utilities specifically written for the OS/2
  Operating System.
  
• Mozilla Suite https://ecsoft2.org/mozilla-suite
  Mozilla suite is no longer mantained. Available alternatives are:
  
• BeeBEEP 5.6.1 https://ecsoft2.org/beebeep
  BeeBEEP is a secure network chat.
  
• ELEPHANT 1.21 https://ecsoft2.org/elephant
  A Tiny Dancing Elephant with a digital clock.
  
• REXX for the absolute beginner 08032012
  

https://ecsoft2.org/rexx-absolute-beginner
A number of simple REXX procedures for beginners with REXX, accompanied by
an explanatory text in the Dutch language, in ASCII, INF, incl.

• IRxRadio 2.0 https://ecsoft2.org/irxradio
  REXX frontend to Mplayer mplayer for playing streaming radio and managing
  a favourite list. Program interface looks like an old tube radio.
  
• Fontconfig & Freetype 2.12.4 & 2.8.0
  

https://ecsoft2.org/fontconfig-freetype
A runtime and a developer package that combines Fontconfig and FreeType
into one package in such a way that it should be easy to build a
cairo-based Mozilla build.

• HWman (OS/2 Hardware Manager) replacement class Release 14

https://ecsoft2.org/hwman-os2-hardware-manager-replacement-class
A WPS class replacement for XWorkplace HWManager (the OS/2 Hardware
Manager).

• GNU sed 4.7 https://ecsoft2.org/gnu-sed
  GNU sed (stream editor) is a non-interactive command-line text editor.
  
• DFSee, Display File Systems 16.1
  

https://ecsoft2.org/dfsee-display-file-systems
File-system display & analysis utility. Shows partition-tables and
bootsectors. Shows all HPFS internal disk structures like Superblock,
Fnodes, Dirblocks etc.

• GNU Tar 1.32 https://ecsoft2.org/gnu-tar
  The tar program provides the ability to create tar archives, as well as
  various other kinds of manipulation.
  
• Driver supporto di base USB 11.17 & 10.227
  

https://ecsoft2.org/usb-basic-device-driver-support
USB basic driver stack including UHCI, OHCI, EHCI (USB 2.0) support,
always required and to be installed first!

• GNU Awk 5.0.0 https://ecsoft2.org/gnu-awk
  GNU Awk is upwardly compatible with Brian Kernighan's version of Unix Awk.
  
• GNU Diffutils 3.7 https://ecsoft2.org/gnu-diffutils
  GNU Diffutils. A series of programs that are used to find differences
  between one or more files.
  
• GNU COREUtils 8.31 https://ecsoft2.org/gnu-coreutils
  The GNU coreutils port from UNIX. This package is the union of the GNU
  fileutils, sh-utils, and textutils packages.
  
• ABOVE512 0.01c https://ecsoft2.org/above512
  ABOVE512.exe marks pure 32bit code and/or data objects of existing LX
  format DLL modules as 'loading above 512MB'.
  
• Automake 1.16.1 https://ecsoft2.org/automake
  Automake, a Makefile generator, utility for software development.
  
• Rxmous Release 2 https://ecsoft2.org/rxmous
  Rxmous is a simple mouse DLL for REXX, with C source, to returns mouse
  position for clicks on text screens.
  
• Libreria VPX 1.8.0 https://ecsoft2.org/vpx-library
  WebM defines the file container structure, video and audio formats.
  
• FluidSynth 2.0.5 https://ecsoft2.org/fluidsynth
  FluidSynth is a software real-time synthesizer based on the Soundfont 2
  specifications.
  
• Quick & Easy Finances 1.15 https://ecsoft2.org/quick-easy-finances
  The ultimate in personal financial programs for OS/2. This will make the
  rest of the financial programs here look like they were developed in the
  early 1990's.
  
• Mplayer 1.4 https://ecsoft2.org/mplayer
  Port of MPlayer: it is a movie player which runs on many systems (see the
  documentation).
  
• Icecast 2.4.99 https://ecsoft2.org/icecast
  Icecast is a free server for network streaming of multimedia contents.
  
• SDLMAME 0.170 https://ecsoft2.org/sdlmame
  A MAME Version based on SDL Library. MAME stands for Multiple Arcade
  Machine Emulator.
  
• Estensione macro LPEX per VAC Release 2
  

https://ecsoft2.org/lpex-macro-extension-vac
LPEX macro to support opening of files by dropping them onto LPEX window +
dropping marked text fragments from EPM (Enhanced Editor, the default OS/2
& eComStation's development editor).
From: [[email protected]](mailto:[email protected])
Source: eCSoft/2
Source: OS2VOICE.org
from OS2World All News http://bit.ly/2WpZfBv
via IFTTT

I made this collection of links for my coworkers to spread the word on Julia. A lot of this is stuff I got here from other posters on reddit. I tweaked it a bit for here to remove some of the things that relate to my job.
Please let me know if there is anything I could add or remove (though keep in mind that most people this was originally aimed at don't necessarily know much beyond Excel, VBA and SQL). If there is some tutorial that I'm missing, didn't give proper credit to someone, broken links, or any other kind of feedback, please do let me know!
ChrisRackauckas, you feature prominently here, please tell me if you're not comfortable with how I've phrased things or what I've included.

Videos

A handful of videos I've seen and liked that are available on YouTube from different JuliaCons.

• Learnings from scaling Julia up to process petabytes in Production: Jacob Quinn, engineer from Domo talking about using Julia to do statistical analysis on huge amounts of data. 13 minute video.
• State of the Data: Jacob from above giving an update on the state of all the different packages for data handling (CSV, DataFrames, Tables.jl, etc). 11 min.
• Julia in a multi user production capital modelling: A large insurance company using Julia for modeling in a production environment. Tim Thornham from Aviva, an actuary, talking about building two of their production models in Julia. 57 min.
• Julia and the Next Generation Airborne Collision Avoidance System: Lincoln Labs/FAA using Julia instead of Matlab/C++ for planes not crashing into each other (seems like a non-trivial task). 32 min.
• JuliaRobotics: Making robots walk with Julia: I'm not really into robotics, but I found this video fascinating (and I could actually follow most of it, unlike some of the other talks at JuliaCon). Super enjoyable, at least for me. 40 min.
• How We Wrote a Textbook using Julia: another super interesting watch. They used Julia, LaTeX and other fairly new technologies to create a textbook where they could change examples, illustrations, etc. just by changing the code. Eliminated the need for a time-consuming back-and-forth with typesetters.
• Heterogeneous Agent DSGE Models in Julia at the FRBNY: a research analyst from the New York Fed discusses how they use Julia for their economic modeling.
• The Unreasonable Effectiveness of Multiple Dispatch: covers how multiple dispatch differs from other programming paradigms, such as OOP, and how it allows for the extensibility in Julia's ecosystem.
• What's Bad About Julia: straight from the horse's mouth. Jeff Bezanson, one of the original co-creators, talks about some of the well-known and less well-known issues with the language. After the first several minutes, this talk took off and went beyond what I can understand, but what it conveyed to me is that these guys are listening to the community and are actively working on solving the known problems.

Articles/Blog Posts

It’s a lot of reading, but if you're interested or curious, these articles are well worth it.

• The Julia Project and Its Entities. A piece by Stefan Karpinski, one of the original co-creators of the language, explains the different (and confusing) Julia entities and what they do.
• What is Julia? A fresh approach to numerical computing: a fairly comprehensive high level overview of the language and how it compares to other languages in the same domain.
• Will Julia Replace Python and R as a Data Science Tool? A data science blogger gives a fairly measured take on Julia compared to its main competitors in the data science sphere, Python and R. Note that some of the info is already outdated (there is now a debugger available).
• Meeting Julia, a great new alternative for numerical programming — Part I benchmarking: another Medium post, goes into a lot of CS detail.
• Meeting Julia, a great new alternative for numerical programming — Part II a high-level perspective: there is a great quote in there about programmers being resistant to change.
• An introduction to the Julia language, part 1: a good, quick intro to Julia.
• An introduction to the Julia language, part 2: one of my favorite posts, helped me wrap my mind around the multiple dispatch concept.
• Why I use Julia: a great, quick article by a statistician expounding the merits of multiple dispatch and why Julia is really more about enhancing and expanding your productivity (and your possibilities) rather than just being fast and easy. Disclaimer: he now works for Julia Computing.
• Julia: come for the syntax, stay for the speed: this is a fairly quick, high-level read, but it kinda got the headline backwards (unlike the one above) -- it should be come for the speed, stay for the other goodies.
• A Mental Model of Julia: how to think about Julia as compared to other languages.
• DiffEqFlux.jl – A Julia Library for Neural Differential Equations: the cutting edge of machine learning research -- using differential equations with neural networks.
• Why Swift for TensorFlow? A post by the TensorFlow 2.0 project team at Google detailing how/why they picked Swift. It's interesting to note that they narrowed it down to two languages for their project: Swift and Julia. Long read, skip toward the bottom to see why they didn't pick Python, C# and a number of other languages. Here is their rationale for their final decision:

In the end, we narrowed the list based on technical merits down to Swift, Rust, C++, and potentially Julia. We next excluded C++ and Rust due to usability concerns, and picked Swift over Julia because Swift has a much larger community, is syntactically closer to Python, and because we were more familiar with its internal implementation details - which allowed us to implement a prototype much faster.

It's interesting to note, however, how one of the authors of the blog post is Chris Lattner...the creator of Swift.

• Google Cloud TPUs Now Speak Julia: this stuff is way over my head, but interesting nonetheless. There might be a link in there somewhere on the more academic paper they released on this research.
• Illustrating the Benefits of Openness: A Large-Scale Spatial Economic Dispatch Model Using the Julia Language: fairly long econ paper on using Julia and JuMP instead of licensed, "black-box" software. (Note: this will download the pdf directly in your browser.)
• Julia: The Goldilocks language: more of a human interest story, detailing the genesis of the language.
• Julia is more than scientific computing: an overview of how the company Invenia views the Julia community and its impressions from the recent JuliaCon 2019. Written by LyndonWhite.

Podcasts

A handful of podcasts I've come across where Julia is being discussed. I haven't yet listened to the ones with asterisks next to them.

• RCE 107: Julia: the Julia co-creators discuss the language for about an hour.
• Julia, Python & R – The Rise of Jupyter Notebooks: two of the co-creators discuss the rise of Jupyter notebooks.*
• Julia Language with Jeff Bezanson: one of the co-creators of Julia discussing the language, similar to the RCE episode but just Jeff.
• Google and Amazon: The Future of Data Centers?: Keno Fischer, co-founder of Julia Computing and early contributor to the language, gives his take on cloud computing.*

Tutorials/Learning Materials

There are a handful of learning materials available on Julia, including some textbooks you could buy on topics such as Data Science and Linear Algebra. As everyone knows at this point, and continues to point out, the availability of learning materials is not as great as that of more established languages like Python or C#. But there are some, and here are a handful of resources I've come across.

• The JuliaCon videos on YouTube. JuliaCon 2019 just happened in July, they had some great talks. JuliaCon 2018 also has a lot of interesting videos. There are earlier JuliaCons but those are before v1.0 happened and I haven't seen to many of them. A lot of the topics they cover are fairly advanced though, but some are pretty general and some aren't even Julia specific.
• The book Think Julia seems perfect for beginners, or even those have some programming but want/need a review.
• From Zero to Julia!: good, quick intro to the language; probably the best place for a quick start. The guy who made this is a super friendly Italian physicist, our very own TrPhantom8 here on reddit!
• Julia - Learn X in Y Minutes: super helpful quick start guide to using Base Julia functions
• The Julia Express: a 15-page quick-start/cheat-sheet by Bogumił Kamiński, who incidentally gives some of the best answers on places like StackOverflow.
• A Deep Introduction to Julia for Data Science and Scientific Computing: this is actually a good place to explore even if you're a beginner. Some highlights:
  • A Basic Introduction to Julia
  • Why Julia?
  • Introducing Julia: The Julia Wikibook
  • Noteworthy Differences from Other Languages
  • Julia Cheatsheet Reference (with MATLAB and Python)
• Quantitative Economics with Julia: pretty good way to get started with Julia, gives a good overview of the basics (and one of its authors is a Nobel prize-winning economist).
• Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence: draft of an online textbook.
• JuliaAcademy: free online coursework on learning Julia, machine learning and parallel computing.
• More learning materials here, includes some of the above: https://julialang.org/learning/

The Data Ecosystem

I was going to add the first post below under Reading, since it's a blog post, but given the centrality of the topic, it deserves its own section.

• A Tour of the Data Ecosystem in Julia: Jacob Quinn, data engineer at Domo and active contributor to Julia's data ecosystem, on the state of said ecosystem (this is a more digestible version of the second video in the Watching section).
• Everyone’s Favorite Blogpost: CSV Benchmarks: more of Jacob, doing some benchmarking against other popular csv readers for Python and R.

Case Studies

The case studies on the Julia Computing website. A lot of interesting stuff being done with Julia, I encourage you to browse through it. I linked some of these videos up above, so browse here if you'd rather read than watch. A few of the highlights:

• Aviva Solvency II Compliance: a quick write-up of how Aviva, one of the largest insurers in Europe, converted one (and then another) of their models to Julia. Read this if you don't want to watch the hour long video linked above.
• Safer Skies: Lincoln Labs/FAA using Julia for the Airborne Collision Avoidance System. Went from two types of pseudo-code, prototyping in Matlab, and rewriting in C++ to just using Julia.
• New York Federal Reserve Bank switching from Matlab to Julia. Here is their documentation on rewriting their Dynamic Stochastic General Equilibrium model:
  • The DSGE MATLAB to Julia Transition: Improvements and Challenges: note that this is from 2015 -- although some of the challenges they note at the bottom are still true, some of them aren't -- a lot of progress has been made since then.
  • Macroeconomic Forecasting with DSGEs Using Julia and Parallel Computing: transferring another part of the model. Check out the design principles section -- they seemed to have used Julia's type system in pretty clever way.
  • Forecasting with Julia: a post on their blog about the process in the above link.

Musings from Chris

Chris Rackauckas is powerhouse of a Julia user and a very vocal member of the community. In fact, he's one the core members of the Julia open source community that leads the team that develops the DifferentialEquations.jl library. He is also one of the main developers of the Pumas software, which is aimed at pharmacometricans. He's currently an applied mathematics instructor at MIT and is affiliated with Julia Lab.

• His CV
• Link to his research page.
• His blog: http://www.stochasticlifestyle.com/. A few pieces from it that seem relevant:
  • The Nonlinear Effect of Code Speed on Productivity
  • Some State of the Art Packages in Julia v1.0
  • Why Numba and Cython are not substitutes for Julia
  • A Comparison Between Differential Equation Solver Suites In MATLAB, R, Julia, Python, C, Mathematica, Maple, and Fortran
• A comment Chris made on reddit in response to why he switched over from a bunch of other languages (emphasis mine):

“I used to use a smattering of C, MATLAB, Fortran, Javascript, R, Mathematica, and Python. Yes, that's a big mess. The issue was... they all had major problems which were fundamental to their setup and design. MATLAB has no pretense of having any nice structure for developing real code (it didn't have arrays of strings until MATLAB 2017a, or any data structures like stacks or priority queues, or namespacing for packages, etc.). R and Python put simple object models on the language. R actually had 3 (now I think it has 5?) incompatible object models. With both R and Python if you actually use objects then your code slows to a crawl. That puts them in a weird spot: people say Python is object-oriented but you won't actually use objects in numerical code because looping over objects is super slow, so is it really OO if you're not supposed to be using them in any real case? Philosophical conundrum.
And then there's Javascript. I tried contributing to some Javascript numerical libraries and learned why people don't even like it for web development.
I was trained in C and Fortran for HPC and MPI, so those were tools I carried around with me. MATLAB's MEX interface is complicated as all hell (take a look for yourself if you've never seen it) so I never really interfaced them all that much with MATLAB, but using them on their own is a usability joke (outputting files to plot later! :) ). With Python+R I built a multilanguage monstrosity but wasn't happy with it. Needless to say, this setup could get stuff done but only was pieced together by duct tape and I knew exactly what the unfixable problems were so I wasn't happy with it.
So in graduate school I wrote 3 attempts at a stochastic partial differential equation solver library in MATLAB, basically trying again and again to get something decent by building a DSL from string parsing and then using a bunch of options to dig down into GPU-parallelized kernels. Stefan Karpinski says that in any sufficiently large library there's an implementation of multiple dispatch, and it definitely rings true here. When I finally got some adaptive stochastic differential equation solvers working, the big hold up was that the lack of efficient data structures (stacks and priority queues) along with the fact that it had to be written as quick loops means that my benchmarks were only okay.
So I took the dive to try Julia, and when I re-wrote what I had been working on it became DifferentialEquations.jl. Needless to say, that re-write worked out quite well so I have uninstalled everything else and only use Julia now.
While Julia isn't without issues, it is without unsolvable issues. That's what I really like about it from a developer standpoint. MATLAB is a blackbox that you cannot change. R and Python will never have fast objects (by design they cannot compile to anything efficient given their mutability of field structure among other things). Numba and Cython are fine if you work with only Float64 codes, but that's the same issue of throwing away the whole object model (in recent years they got a way to write simple objects only compatible in these frameworks, but you can't simply re-write the standard library yourself to get some objects because they aren't compatible with the operations of Python objects... yay?). Without multiple dispatch its hard to get any kind of generic programming going in Numba/Cython or efficiently write codes which need heavy specialization (numerical codes). I don't like the local optima that R or Python puts you in where it gives you unsolvable issues and alters your code for performance.
But Julia is you and me. The Base library is Julia code. If you don't like how it's performing, do u/ and see what it's doing. I've modified many many Julia packages to get what I need since it's a simple flip to go from user to developer. And the core Julia issue, the next steps beyond the simple JIT model, already have solutions. There are ways to statically compile Julia code, and there is a Julia interpreter that has been written so that not all code has to be compiled. These haven't been incorporated well into Julia, but that's just a tooling issue. Julia still has issues because it is young, but those issues actually have real solutions, and I can contribute to them directly using Julia code!
And I'll leave you with this. Python's manual literally says
It is quite easy to add new built-in modules to Python, if you know how to program in C
Here's the link: https://docs.python.org/3/extending/extending.html . Yes, Python is super easy if you know C guys. There's the whole page showing you how to make pointers to Python objects, just the way you've always wanted to write your numerical codes if you wanted to loop fast... uninstalled.”

​

Community

The Julia community are physically scattered all over the world, although Julia Lab is centered at MIT. Here is where they hang out online:

• Julia Discourse: this is where most of the community is, including the core developers. One of the better places to ask questions.
• Julia Slack: you need a registration/invite for this. Supposedly the quickest place to get an answer.
• www.reddit.com/Julia/: pretty self-explanatory. Go here if you're embarrassed to ask questions on the big dog forums (though some of the big dogs are on reddit as well). This forum is not properly moderated so occasionally low quality content pops up, unlike Discourse and Slack.
• And of course, the whole project is hosted on Github, where issues get reported and discussed.
• Blog on the Julia Computing site: this contains announcements related to their products/services and other goings-on in Julia world.
• Blog on the Julia Lang site: this is the more interesting of the two official blogs, it concerns developments in the language and its ecosystem.

Notable Libraries

Here are some of the notable libraries that have been developed in the Julia ecosystem. A few of these are considered state of the art/cutting edge (see Chris's musings). Although there are not nearly as many libraries as there are for R or Python, there are still quite a bit. Moreover, quantity does not equal quality. So far Julia has a small quantity of high-quality libraries written by very dedicated members of the community.

• Flux: one of the main machine learning libraries. Haven't used it, but I've read that it's a good way for a beginner to explore machine learning. The word flux is a not-so-subtle reference to Google's TensorFlow library for machine learning. The 1.x series of TensorFlow is notoriously difficult to use, which is why the Flux authors captioned their library with "Relax! Flux is the ML library that doesn't make you tensor". However, the most direct analog to Flux would probably be PyTorch. Both TensorFlow and PyTorch are Python-based tools.
• JuMP: a domain-specific modeling language for mathematical optimization embedded in Julia. It currently supports a number of open-source and commercial solvers ... for a variety of problem classes, including linear programming, (mixed) integer programming, second-order conic programming, semidefinite programming, and nonlinear programming. JuMP makes it easy to specify and solve optimization problems without expert knowledge....
• DifferentialEquations: <- that's the project homepage, and here is the README on Github. Supposedly one of the most comprehensive suites of diffeq solvers available anywhere.
• JuliaStats: a meta-library for all sorts of probability and statistics functionality, including Distributions, a package for probability distributions, and GLM, a package for linear and generalized linear models in Julia.
• CSV: A fast, flexible delimited file readewriter for Julia.
• DataFrames: Tool for working with tabular data in Julia. Supports missing values. Julia's equivalent to Python's Pandas.
• Plots: a meta-library of plotting libraries, including ones popular for Python and R use.
• GadFly: a plotting and data visualization system written in Julia. Based on the idea of ggplot2.
• StatsPlots: a plotting library for use with the JuliaStats packages.
• Makie: more visualizations!

Julia Survey

Here is a link to the survey they recently conducted, which includes the slides they presented at JuliaCon 2019.