My name is Ashish Mahabal, and we'll
be continuing with the module on best
programming practices,
the last part of it.
So today we'll be seeing a little
bit about portfolio building.
But before that,
just a quick word about metaprogramming.
So what that means is that,
you want, you will want to separate
some configuration files, which have
specific data which can be changed by
either the user or you, yourself will be
changing that later that allows you to
have all the abstraction in your code.
And then that can be separated, which
doesn't have to be touched again, and
again, or perhaps even ever
once you have the metadata, or
the bits that need to be changed
in separate configuration files.
So you should have those configuration
files for various things that those can be
plain text files, and
you can change that very easily, later on.
[COUGH] When it comes to
portfolio building, what I
would like to advise is that you should
have as wide a repertory as possible.
So you should have mastery of say,
one or two languages.
But also have many general
tools at the tip of your hands.
You should especially learn
how to handle plain text.
Many people, I've found, just don't know
how, when they're sent a plain text file,
what to do with that.
You should remember that it's easier to
test, you can have config files in that or
the other thing that you should
remember is you would normally be
accessing shells on your computer like
especially if you're Unix like computers.
Learn how to handle those and
there are very powerful programs that
the shells come with like find and
said and arc and create.
Make sure that you know
them at least to an extent,
because rather than writing
some long programs,
you'll be able to adjust those
programs to do a lot of work for you.
Similarly, if you are using a batch, or
CSAs, then there are some batch
RC DCHRs like files that go with them.
Learn about the details of those, and
you'll be able to accomplish a lot by
knowing the intricacies of such things.
And it's not a big learning curve,
it's fairly straight forward to learn.
Just the very fact that they exist is not
known to many people, but once they get
into it they realize how quickly they
can do a lot of things with those.
Similarly with languages,
try to learn some languages that have
completely different flavors,
some that you need to compile,
some where spacing is important,
some in which spacing is not important.
Because all of them have their strings and
then once you know some different types
then you'll be able to use them in
different situations more efficiently.
Again with editors, I'm sure that each
of you have some favorite editor and
it's good to know that
as much as possible.
But make sure that you know a couple
others at least to an extent.
If you are very good eMax, try to learn
VI or Sublime or something like Nano.
And you'll find that sometimes you'll
find using the editor quickly for
something short is very useful or when
someone else is describing something to
you in their favorite editor,
you'll be able to get that quite well.
So each of these editors comes
with various interesting tools
which are time-saving, like syntax
highlighting is possible these days,
auto completion, auto indentation,
and various Boilerplates, and
of course there is built in help.
So, try to make sure you
understand of those.
And, like was mentioned before,
you have cheat-sheets, even for editors.
So make sure that you have those printed
out and put next to your work space so
that you can take a look at
them whenever you want to.
Then if you are trying to do some text
manipulation, language like Bowline,
Ruby, are extremely
powerful in doing that so
learned just a little bit
of those two languages.
And there can be various code generators
that will help along in a big way.
So small subroutines that can go with
this code generator can write most of
your code quite easily.
These also include shell scripts that can
be fairly easily written or config files.
We talked about those
a little bit earlier.
In our transient astronomy we
have something called we have
built something called Skyalert.
And when a new transient is found,
a transient is an object that changes in
brightness and
we are interested in studying those.
When a new transient is found
the Skyalert auto code generator,
the active code generator goes out and
fetches data from various archives.
And then, it incorporates those
data into the data that we
farmed from the transient.
And then, if certain conditions are made,
then it can do additional things like
running some other programs or
raising an alert, et cetera.
So, it becomes very handy, being able
to write such, active code generators.
And it's not difficult,
so that's definitely something that you
should try to make part of your portfolio.
Then there are various
websites that you can visit,
like the 99 bottles of beer website.
It shows how to write that particular
program in various different programming
languages and that allows you to
compare how those languages work and
similarly there
are programming shoot outs.
You can compare different
languages there that
are of course various debates that go on.
But here is a more objective look at
various features of different languages.
Similarly Project Euler
is a fantastic resource.
There, there is mathematically
problems of state aid and
you're suppose to use programs to
solve them and once you solve them
you get access to of the same program
written in other programming languages.
They simply, in the site was hacked and
for some time that may not be available,
but I'm sure that'll be coming back soon,
and it's a fantastic resource.
You already saw earlier
about memorization.
Definitely that's something
you should learn about,
radius, caching digits, et cetera.
I won't go into more
details of that right now.
I'm going to leave you a bit,
a couple of exercises.
It is an exercise.
If you are given a certain amount and if
you want to find out how many ways there
are of dividing that amount using say
the standard US coins pennies, nickels,
dimes and quarters, that is coins of
denomination one, five, ten and 25.
How can you do that?
The problem is normally stated where you
want to divide 100 cents into 1s and
5s and 10s and 25s.
If you start with simply a one, if you are
separating a single penny into these four
denominations, there'll be
only one way of doing that.
Two, three, four, again,
there'll be one way of doing that.
But the moment you come to five,
you can either get one coin of five, or
five coins of one.
So there are 2 ways.
And then, as you go to higher numbers,
there'll be multiple ways of doing that.
So the next part of the question, and this
is where you'll be able to build your,
program is, you should answer this
question for all numbers from one to 100.
And then, having answered that,
you should find out the ones that,
which have, which return and odd number of
different number of ways of doing the sum.
And then, you should simply
say whether the odd number of
numbers that odd or even.
So that's essentially an exercise so
you should definitely try to take a,
give it a go.
Here is another exercise.
On lifehacker.com sometime
back a program was put
out about a better strategy for hang man.
Given a particular length of word
that you are looking for and
given frequencies of letters
in different words how one
can solve that in a meaningful and
easy fashion.
I'd like you to try to solve the same
thing using only Unix commands.
I mentioned a few earlier so
try to take a look at that.
But that will stop back summarizing
one of the lessons that we
may have learned from this
best programming practices.
You should remember that a chain
is as weak as its weakest link so
try to have your portfolio include
many strong of languages, and
find the strong features of each of them.
include a lot of comments wherever
possible, for yourself and for others.
Make sure that you write lots and lots of
tests, that your programs are orthogonal.
Don't duplicate yourself,
design by contract, and
again, know the features of the language
of whatever module that you are using.
In debugging, try to optimize your
programs in the way that we have told you
about, not in arbitrary ways.
Follow the best practices and
have fun coding.
Thank you