I have heard a lot of people saying "Jupyter" with "py" as in Python, while others say "Jupyter", with "py" as in the name of the planet.
So, what is the most correct form?
Fortunately, there are many videos and podcasts with Fernando Pérez and Brian Granger, core developers of IPython/Project Jupyter and we can easily check them. They say Jupyter with "py" as in the name of the planet.
Here is an example of Fernando Perez talking about Jupyter, in PLOTCON 2016: Fernando Perez, The architecture of Jupyter.
Related
What is the difference between vi and vim editor?? I want difference in technical point of view not in theatrical. If you gave example then it is much helpful for me or all the readers.
From the vim documentation:
Vim is a text editor that is upwards compatible to Vi. ... There are a lot of enhancements above Vi: multi level undo, multi windows and buffers, syntax highlighting, command line editing, filename completion, on-line help, visual selection, etc.. See
":help vi_diff.txt" for a summary of the differences between Vim and Vi.
The vi_diff help page is quite extensive; it's over 1000 lines as of vim version 7.4. That's the best place to look. You can access it in vim by running :h vi_diff, or online at http://vimdoc.sourceforge.net/htmldoc/vi_diff.html.
You should also be aware that on many systems running vi will actually invoke vim, because of the presence of either a hardlink or a symlink (or maybe even a script or executable, which I've seen). But there are slight differences between the two methods of invocation; for instance, running vi may not load your .vimrc.
vim has vi's features plus other features like, the ability to visually select blocks of code, and much more. Syntax coloring/highlighting as well. You can use vim for just about anything you would use vi.
Vim stands for Vi IMproved. It has been ported to multiple different platforms, but is functionally almost the same. Wikipedia it!
I am a fan of Qt and the more i learn about it, the more i love it. I don't know why it is named Qt. I searched it but all of the results where irrelevant. Most were acronyms like "Quality Time" and some were "cutie" or "quiet".
I thought may be it is a funny acronym like "GNU" which is GNU's not UNIX. Either way it is such a cool and cute name. Anybody know about it?
Quote from the first edition of C++ gui programming with Qt 4:
The letter ‘Q’ was chosen as the class prefix because the letter looked beautiful
in Haavard’s Emacs font. The ‘t’ was added to stand for “toolkit”, inspired by
Xt, the X Toolkit.
*Haavard Nord and Eirik Chambe-Eng began the development of Qt
The same piece of history is on wikipedia
"The letter ‘Q’ was chosen as the class prefix because the letter looked beautiful in Haavard’s Emacs font. The ‘t’ was added to stand for “toolkit”, inspired by Xt, the X Toolkit. The company was incorporated on March 4, 1994, originally as Quasar Technologies, then as Troll Tech, and today as Trolltech."
So it should be Quasar Toolkit.
References: 1.https://answers.yahoo.com/question/index?qid=20130907190045AAZZ9uM
2.http://formfull.in/qt
I am currently trying to get a grasp on asdf, but sadly (but apparently not uncommonly) the standard user guide is not really of any help, as it does explain (I guess) the relevant parts but misses to distribute some extended examples containing comments, so a newbie can see those commands in action.
I am especially interested in the usage of :defsystem-depends-on and the :components
part of the defsystem syntax.
Therefore the question is: Is there a more sophisticated and newbie-friendly user guide for asdf out there than the standard user guide?
I don't have time to write a comprehensive tutorial (and I don't have a comprehensive understanding), but I can provide a link & copy from a project I have.
(asdf:defsystem #:cl-yahoo-finance
:depends-on ( #:drakma #:babel #:cl-csv #:yason #:url-rewrite)
:components ((:file "cl-yahoo-finance")) ;;cl-yahoo-finance is cl-yahoo-finance.lisp, in the same directory.
:name "cl-yahoo-finance"
:version "3.2"
:maintainer "Paul Nathan"
:author "Paul Nathan"
:licence "LLGPL"
:description "CL interface to Yahoo's finance API"
:long-description "Common Lisp interface to Yahoo's finance API, available over the web. See usage.lisp for example code.")
https://github.com/pnathan/cl-yahoo-finance/blob/master/cl-yahoo-finance.asd
Do you have any specific questions?
:defsystem-depends-on is just some systems which must be loaded before the system definition is processed. From the grammar you can see that a system name is either a string or a symbol.
:components - many uses are relatively simple. For example it would list a bunch of files.
See also the grammar of ASDF DEFSYSTEM.
I've found this dictionary by William Whitaker on the Internet and I like its parsing capabilities. But the output doesn't fit for me.
The issue (challenge for me):
Given an input form such as "audiam", the program returns the following output (plain text):
audi.am V 4 1 PRES ACTIVE SUB 1 S
audi.am V 4 1 FUT ACTIVE IND 1 S
audio, audire, audivi, auditus V (4th) [XXXAO]
hear, listen, accept, agree with; obey; harken, pay attention; be able to hear;
But I just want to receive the following text output (same input: audiam):
audiam=audio, audire, audivi, auditus
That is:
InputWord=Dictionary_Forms
So some pieces of information are needless for me.
How can I change the output of this program by modifying the Ada code?
I don't have any Ada knowledge, but I know Delphi/Pascal so it's quite easy to understand the code, isn't it? So the parts causing the text output seem to be the TEXT_IO.PUT(...) statements, right? They're all called in list_package.adb so this is probably the source file to look at.
What has to be changed in particular?
The full Ada 95 source code of this program is available on this page.
I hope some of you are able to understand Ada 95 code. Thank you very much in advance!
My compiling problems:
For use on a windows machine, I downloaded MinGW and tried to compile the source files using "MinGW Shell". But this was my input and the shell's reponse:
Compiling with the latest Cygwin version:
When I compile the program using the latest version of Cygwin, there is no error message:
There is even an .exe file which is created. Its size is 1.6 MB (1,682,616 bytes). But when I open it, it closes right away. What has gone wrong?
William Whitaker's Words is a handy tool. You may be able to find a version already built for your platform. I've not changed the code, but you can alter some things using various parameters. It's even hosted online. If you get an Ada compiler, I've included the last Makefile I used. It's a little thin on abstraction, but it includes the essential steps to compile the program and utilities, along with the steps to build the dictionaries.
TARG = words
ARGS = -O
$(TARG): *.ad[bs]
gnatmake $(TARG) $(ARGS)
all: $(TARG)
gnatmake makedict $(ARGS)
gnatmake makeinfl $(ARGS)
gnatmake makestem $(ARGS)
gnatmake makeefil $(ARGS)
#echo Please make the dicitionary
#echo ./makedict DICTLINE.GEN
#echo ./makestem STEMLIST.GEN
#echo ./makeefil EWDSLIST.GEN
#echo ./makeinfl INFLECTS.GEN
debug:
gnatmake -g $(TARG)
clean:
rm -f *.o *.ali b~* core
cleaner: clean
rm -f *.s makedict makeinfl makestem makeefil
cleanest: cleaner
rm -f $(TARG)
Addendum: One approach is to use gcc 4.4.3 on Ubuntu 10.04 with the updated Makefile above. For convenience, I used VirtualBox to host the linux instance.
$ gcc --version
gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Here's a quick test using the title of my second favorite passage from Catulli Carmina.
$ ./words odi et amo
odi V 6 1 PRES ACTIVE IMP 2 S
odeo, odire, odivi(ii), - V TRANS [EXXCW] Later
od.i V 4 1 PRES ACTIVE IMP 2 S
odio, odire, odivi, - V (4th) TRANS [FXXCF] Medieval
hate; dislike; be disinclined/reluctant/adverse to; (usu. PREFDEF);
odi N 2 4 GEN S N Early
odium, odi(i) N (2nd) N [XXXAO]
hate/hatred/dislike/antipathy; odium, unpopularity; boredom/impatience;
hatred (manifested by/towards group), hostility; object of hate/odium;
od.i V 3 1 PERF ACTIVE IND 1 S
odi, odisse, osus V (3rd) PERFDEF [XXXBX]
hate (PERF form, PRES force), dislike; be disinclined/reluctant/adverse to;
et CONJ
et CONJ [XXXAX]
and, and even; also, even; (et ... et = both ... and);
am.o V 1 1 PRES ACTIVE IND 1 S
amo, amare, amavi, amatus V (1st) [XXXAO]
love, like; fall in love with; be fond of; have a tendency to;
Addendum: Once you've got it running, the problem of modifying it remains. A grep for Put_Line\( shows 629 hits; most are in line_stuff and list*. That's where I'd start. As you are learning Ada, there are several good tutorials here.
As much as I like Ada and would encourage you to learn the minimal amount it would require to hack it the way you want...
Really, you are asking for a simple data filter, which it would be quite easy to accomplish by piping your output to awk. If you are running on any flavor of Linux you have awk already (and really should learn to use it). If you are on Windows, you can get awk and all sorts of other useful goodies from MinGW, which is one of the places you'd need to go to get an Ada compiler anyway.
If you do want a Windows Ada compiler, I'd suggest getting GNAT/GCC from there. The two other flavors available, GNAT/GPL and GNAT/PRO are available from AdaCore (the maintainers). However, GNAT/PRO must be purchased and GNAT/GPL renders distributions of any program compiled using it GPL. You might not mind the GPL applying to your program I suppose, but I'm guessing this isn't a serious enough need to spring for commercial support.
If you are on Linux, the GNAT Ada compiler should be available with GCC as an option (if not installed by default). The same two other options from AdaCore are available there too of course, if you like.
Well, you asked about learning Ada. Really, if you are familiar with other compiled procedural languages (eg: C/C++, Java, Pascal, Modula-2, etc.) you shouldn't have too much trouble picking it up. This question covers Ada books. For myself, I generally just use the official LRM as a reference. Unlike most languages, Ada has an internationally standardized Language Reference Manual that is available online for free. It is also quite readable, as such things go.
About compiling: you can use GNAT. It supports Ada83, Ada95, and Ada05. To tell it to use Ada95, use the -gnat95 switch.
You can get it on http://libre.adacore.com/
What's the story behind our massive repitition of ./foo and cd ... Where do these two . and .. come from? Where could they be seen as a way of navigating a file system tree for the first time?
Excerpt from an interview with Ken Thompson (9-6-89):
Every time we made a directory, by
convention we put it in another
directory called directory -
directory, which was dd. Its name was
dd and that all the users directories
and in fact most other directories,
users maintain their own directory
systems, had pointers back to dd, and
dd got shortened into ‘dot-dot,’ and
dd was for directory-directory.
I'm sorry I can't answer properly, but I can recommend these links:
The Evolution of the Unix Time-sharing System and
A Brief history of the BSD Fast File System
for some interesting historical notes on early file systems and their use.
Other than that, the earliest reference I've found is the 1974 paper "The UNIX Time-Sharing System" by Dennis Ritchie and Ken Thompson. The precursor of UNIX, Multics, also had hierarchical file systems and the notion of relative paths, but according to "Introduction to MULTICS" it used another notation for that.
I believe it was invented by Dennis Ritchie at Bell Labs in the early years of Unix.