Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
Not sure if this is the right forum (and if so, point out to me and I will delete this post!).
I had been evaluating languages to replace a existing code written in R that has around 4k-5k lines(and used for live trading), primarily to get speed and I liked Julia (v0.2.0) - not only for its speed, but also because the language is easy to learn.
I would like to initiate a project to rewrite the existing R code in Julia, but since it can be a major exercise for me, I wanted to ask if there is any information available anywhere whether the future releases of Julia will be largely backward compatible with Julia v0.2.0?
For example, one issue I faced earlier with Python was that v3.0 onwards are not quite backward compatible with v2.7, and v2.5 codes don't often work on v2.6, v2.6 codes don't often work on v2.7, requiring significant rewrites because you have to carefully evaluate where the old code broke (and was almost always better to rewrite the code from fresh). I want to avoid the same issue with Julia.
While Dirk is right that anything is on the table for changing up to version 1.0, we do have some assurances about compatibility:
There is a release-0.2 branch that will contain only bug-fixes, so if you write code for Julia 0.2, it will continue to work on that branch
We try very hard to deprecate APIs that we change, rather than just yanking them out from under you. This means that your code will keep working, but you will get a warning telling you the new way to do something.
There have been very few basic syntax changes in the past year, and I don't really foresee any big ones. Most of the changes that still need to happen are standard library API changes.
"Maybe" but probably not.
Goals for the 0.3 to 1.0 transition are (among other things) to get all breaking changes out of the way.
In other words, between now and 1.0 changes are to be expected.
Related
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 2 years ago.
Improve this question
(Edited to narrow the question to Ada. Have posted other questions for Fortran and COBOL.)
I've spent some time in the past year dealing with changes to my code due to Python v2->v3 and R v3->v4 changes. It got me curious as to some of the older languages that are still in use.
I know Ada still sees occasional updates and functionality upgrades. I would assume that their mission-critical nature makes those changes smaller and more backward-compatible, but I don't really know and couldn't find it with a web search.
What and when were the last changes to Ada that was on the same rough order as the Python 2->3 changes?
Ada pays a lot of attention to reverse compatibility, to avoid breaking existing code, when making changes.
Last formal Ada release was Ada-2012, there is another one (Ada-202X) in progress.
Ada-2012 has a lot that Ada-83 doesn't, but I'd be surprised if there was anything more than trivial work to build an Ada-83 project (or Ada-95 or Ada-2005) in Ada-2012.
There are some differences though : from Ada-83 to Ada-2012 As you can see, there's really not much to say for 30 years of development.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
Workflow for statistical analysis and report writing
This question had a lot of good answers, but as pointed out, they are outdated.
I mostly work on scripts that will probably never be re-run after a paper has been published. Are packages worth the trouble in cases where I don't need to redistribute the codes to the world for easy access? What about the organization of data? How can makefiles be used?
I think if you use the basics laid out by Josh Reichs in that post you provided, making sure that you create a directory to save everything in, then you are good to go.
My added step for the modern world would be to product a markdown report in one of the available formats.
rMarkdown- which you can run right out of rStudio
rNotebooks - which
you can run right out of rStudio
Jupyter Notebooks - which you can
run out of Anaconda or Jupyter with some easy tweaking.
The beauty of these three report systems is that you get to integrate the thought process, code, data, graphs and visualizations in a single spot.
So, if as you say no one will ever re-run your code, then they will at least see it to appease suspicions. Also, if they do choose to repeat your process, they just follow your logic and process in a duplicate document (especially easy with the notebooks)
As for using packages. That is a more complex question. If the packages are well orchestrated and save you a ton of time cleaning, sorting and structuring data, USE THEM! Time is money. If the things you are using them for are simple, straight forward, just as easy to program yourself and recognizable by those who would jury your paper, it probably does not matter either way.
The one place where I feel it matters is complex processes that are difficult (read that as easy to do wrong yourself) and have been implemented, tested and vetted by prior researchers.
Using those packages garners credibility and makes it easier for peers to accept your methods at face value. But if you are on the cutting edge..you should feel free to slice away. Maybe make a package of your own!
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 6 years ago.
Improve this question
I was kind of wondering,how R language works internally when we type some command..
Say License()
As per my understanding,R language is made of packages,When we execute some command,it invokes the Right package,i was not able to find some documentation supporting this..
Research done from side:
1.closest i could get is below link
https://cran.r-project.org/doc/contrib/Paradis-rdebuts_en.pdf
2.I searched using "How R Language works internally",but i could not get any relevant results..
Below is how SQLServer executes a query from starting to end ,i am looking to see similar kind of documentation/any pointers for R
please let me know if you have any pointers
The notion that the R language is "made of packages" is inaccurate. It is made of commands, operators and functions, like other programming languages. Those commands are grouped into namespaces which comprise commands that belong to the same topic. A package provides a set of specific commands (and sometimes other objects, like sample data) grouped into a namespace. By loading a library (there are subtle semantic differences between a library and a package) the namespace of the package becomes available in the global environment, thereby making these commands directly accessible.
On the suggestion of #CapelliC here is a fully typed answer.
The internals of R are included in the document: https://cran.r-project.org/doc/manuals/r-release/R-ints.html
It is not an easy read, but covers all of the detail. My advice would be search the document if you have a specific query...
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
How are versions numbered? What is the proper idea behind going to next version, increments, etc?
For example, I often see v0.1, v0.2, v0.34567 etc. I assume these are softwares that are in beta, and haven't finished the first release yet.
But there are also many softwares that are v0.10.11, etc. how do they work?
There is not a specific standard - anybody can follow any scheme (or lack of scheme). It's up to corporate policy, development standards, or whatever guidelines you are under.
There are some popular standards out there. We try to follow the Semantic Versioning standard. The basic tenants include (quoted):
Given a version number MAJOR.MINOR.PATCH, increment the:
MAJOR version when you make incompatible API changes
MINOR version when you add functionality in a backwards-compatible manner
PATCH version when you make backwards-compatible bug fixes.
Links:
Semantic Versioning: http://semver.org/
Other versioning schemes: http://en.wikipedia.org/wiki/Software_versioning#Schemes
There are competing standards, which saddens me greatly, especially in a world where git is popular.
SymVer, as mentioned, helps a great deal, but a lot of popular software doesn't use it.
Unfortunately, this doesn't help a great deal when dealing with distros, who apply patches to specific versions of software, effectively changing it's version.
The closest to "proper" I have seen yet is done by NixOS. Each version of their software is hashed, as are all patches applied, and each end result has a different hash, line any change in Git.
The resulting output will be different as well, uniquely identifying it against others.
Until that method is adopted, it's a free-for-all, and versioning is not a consistent thing.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
I'm working with a small team of analysts and statisticians on what will be a medium-sized body of R code. They're smart people, but they're not trained or experienced as programmers, per se. (I am.) They've written some R code, but for our project to be expandable, efficient, and maintainable, it needs to become well-structured, and rather more piratical. One of the better way to learn to be a better programmer is to study elegant existing code. Can anyone suggest some open source examples of R code (on CRAN or wherever) that you think are particularly clear, literate, and good examples? Functional is good, S3 objects are OK, deep magic is bad.
My two favorite packages can both be browsed on R-Forge and are very well documented (although they may be too big for an introduction):
The caret homepage and source code.
The zelig homepage and and source code.
I think that the Google style guide does a great job of capturing the style of the Core team, although Hadley has his own style guide which can be read if you're looking at his packages. You can browse Hadley's packages on Github (and his homepage is full of useful content), in particular:
plyr
ggplot2
reshape
This article on the R-Wiki is also a good read for seeing ways to optimize code.
Not strictly related, but make sure you get them used to using Source Control (perforce, subversion, git, rcs, etc) as quickly as possible. That reduces the learning pains.