Pros, Cons, of Codevita. How to Learn Coding?

To all the Students of in and around Tamilnadu, and India!

 For many it would be a busiest weeks ahead because of #CODEVITA 2017 . I Know for sure it wont benefit the students who are new to coding and still win the Game. (Obviously not possible). All can start here. nothing is the formula. but if you like it share with your friends and be the best possible.
PROS:
1. The Event let you know various new Programming Languages out there, Java is not the end (as for many it is).
2. Builds up a competitive Spirit for an unknown task(coding). Life is all about being ready for such unknown task. It is all about your mind. Mind Matters. #PlanPrepareExecute. (formula: P2E)
3. Working as a team in preparation and contest in different levels.
 
CONS:
1. There is no one to reach the basic Programming language itself with all logical sense to the students. its a kind of cycle, teacher then during 80's were so intelligent to learn electrical and then coding, later they gave portion to students of 90's, they intern gave their portion of knowledge to 2K students and there now many, many are the students who think they can get everything from their teachers (they have been told like that, treated like that). But sorry bad luck, it is the era of #SELFLEARNING. 
Solution: BE A SELF LEARNER
2. As it is unknown task, frustration is obvious at any point of time. Come on dear students it is here you have to build your strength. be stronger than ever before.
Solution: It is really here the teachers have to give your hand. Modern days student - Teacher relationship held important at this stage of appreciation and motivation.
3. When and were to be a team as most important, Conflict management and making the most out of the team member is essential.
Solution: No one can teach this. Got to appreciate others equally as yourself.
The following is the best found tips and suggestion from a renowned resource(ABOUT THE Original AUTHOR,Martin Andrew Habich, Summa Delivery Development Manager) for a gradual  progression in Coding. I have updated few (bolded, dark green color texts)
 
Original Source: http://www.summa.com/blog/2013/12/17/10-ways-to-practice-programming Thanks to the author. I have rearranged the points as for the students of this part of the country to prioritize their plans

I hope that you'll get at least one idea for a new technique that works for you. Rotate these into your weekly routine and you'll undoubtedly see dividends on your journey to mastery!

1.Online Courses

 This one is equally as obvious and equally as broad as "books". However, given the recent preponderance of free online resources (affectionately known as "MOOCs"), you'd be doing yourself a disservice if you didn't take advantage of the excellent teachers that are putting world-class instruction out on the internet. I'd also group online tutorials under this category. There are even some amazing online tutorials that provide in-browser REPLs or similar functionality for hassle-free forays into new languages. When I was first dipping my toes into functional programming, I was able to learn Clojure and F# without having to download anything... it's difficult to overstate how convenient that is.
The three biggest MOOCs right now seem to be Coursera, Udacity, and edX. Many universities are also offering free lectures directly. (like from IIT nptel.in courses)

#sololearn, #codeschool are good place to start with,

Many talk the benefit of this for hours and hours, but all stopped after an inauguration session of what is online courses ? no progress so far . Appreciations to some of the beautiful destination for students who encourage this and all following points with much concern


2. Pair Programming 


(Peer Learning, which is not well understood in this part of the country)

I don't want to harp on this one too much, but if you've never tried pairing, you really should. It's staggering how many times you'll have your subconscious paradigms challenged within the first hour of pairing with a new partner. This is particularly great for picking up new ways to attack a problem, subtle style tips, line-level coding tactics, and especially for honing code clarity.
# the colleges and departments must not expect pin drop silence in the practical classes, let them group and let them discuss. If you positively motivate them to utilize time like that definitely, the worthless practical sessions would be much worthy. 
#LetPositiveLearningNoiceArise
very sorry to say many colleges sacrifice this part of learning for unhelpful lesson plan completion and other reasons, Why it still remains, it is because in the midst of this the colleges still being successful, I don't who to be blamed.


3. Read Books

Definitely one of the obvious ones. If you're looking to hone your mechanics, focus on books that discuss general programming practice (Headfirst books series in any major progamming language, Pragmatic Programmer, Code Complete, Clean Coder, etc.) or ones that provide a hands-on walkthrough of a particular language, technology, or architecture. If you've never read it, TDD By Example ( http://www.eecs.yorku.ca/course_archive/2003-04/W/3311/sectionM/case_studies/money/KentBeck_TDD_byexample.pdf )  is a quick read and a great starting place. 
Most of them are not in ollege book shelves, so dont search there, Solution : Online purchase or #Odyssey

4.Solo Pet Projects (we call mini project)

Again, file this one under obvious. Work on personal projects in your free time. There are certain challenges you can only ever learn to defeat when you are the one ultimately responsible for a code base. Also, refactoring your own six-month-old code can be a very... uh... "instructive" exercise.
There's a real growth that occurs any time you own every aspect of a full-stack development process. It's really easy to stand on principle when you're butting heads with a team member. When you're the only one accountable to your decisions (process? language? build tool? package structure?), winning an argument is never a consideration. You have to live with the consequences of every tooling, styling, and implementation detail.
In my opinion, this is probably where the most time should be spent. However, if you never step back to incorporate external learning and practice your skills in a sterile environment (à la kata), you'll never progress past a certain point.
(department can encourage the creamy students well there are many such already out there who are in their own way of building app and all. Make them the teacher for such process. build leadership quality they will be very much motivated)

5.  Code Retreats / Hackathons
I experienced my first code retreat while at SCNA, and I must say, it was pretty fun. It's kind of like a code jam (code weekend? hackathon? whatever the kids are calling them these days) meets pair programming meets code kata meets musical chairs meets Fluxx. If you can get into a code retreat with developers outside of your usual ecosystem, then you'll get to relearn the basics from a bunch of people you may never see again -- and that's a learning opportunity that is hard to replicate. However, the best part is the shifting rules of the game.
While repeatedly pair-solving a coding challenge, the code retreat may impose rotating restrictions on the code you write. Some example restrictions were no iterating through loops, ping pong pairing with no talking (not recommended for day-to-day usage), and only three lines of code per method. While some of these are toy challenges, occasionally you'll forge a few new neurons learning a more elegant way to solve a problem you'd otherwise have solved through rote repetition.
(This definitely need pairing up of students from multi discipline, senors and juniors along with mentoring of teachers who are very interested in such activities. You can see results if you do this, I have seen in my tenure as Assistant Professor)

6. Code Katas (A code kata is an exercise in programming which helps a programmer hone their skills through practice and repetition. The term was probably first coined by Dave Thomas, co-author of the book The Pragmatic Programmer,[1] in a bow to the Japanese concept of kata in the martial arts. As of October 2011, Dave Thomas has published 21 different katas.[2])

a new unexplored concept to learn coding 

Code Katas are a great way to practice some of the lowest-level fundamentals. In short, you take a small (but non-trivial) requirement and build out the code needed to implement that functionality. Then, once you're done, you discard your results and do it again! Undoubtedly, there are diminishing returns to performing the same kata over and over until you have it memorized. However, it's very instructive to watch your approach shift between implementations. Summa Technical Consultant Zack Mance suggests doing one daily first thing in the morning for maximum results.
Katas are great for mastering the process of getting a project up-and-running, for mastering new language or IDE features, and for practicing TDD. There are many available resources online describing the philosophy, as well as bountiful lists of problems to solve. If you're feeling really feisty, some people like to turn katas into a performance art... just make sure you have a good soundtrack to back you up.
Here are a couple of resources I've found with ideas for what to code:
http://codingdojo.org/cgi-bin/wiki.pl?KataCatalogue
The goal is the practice, not the solution.

7. Open Source Software

Why open source software? Because A) you can and B) you have unfettered access to the raw source code of a worldwide network of passionate software developers. Think about that! It's a mind-blowingly staggering resource! There's more than one way to benefit from this opportunity.
Firstly, you can read open source software! To borrow a metaphor from Dave Thomas at SCNA - do you think any great writer ever broke through without reading some of the masterwork literature of authors past? Of course not! So, why aren't we spending time reading code from great open source projects? Sure, the metaphor's not perfect... but if you really want to learn idiomatic constructs or learn how to apply TDD and single-responsibility to keep an overwhelmingly large project manageable, look no further than open source. It doesn't take long to pick up lots of perspective. And c'mon... you can literally see exactly how world-class programmers are doing things. It's amazing! Amazing! The greatest! And it's free! Free!
(Quick sidebar, you can also get a good feel for what bad code looks like if you want to. Sometimes it's good to get a perspective between grok-able code and gobbledygook. Just make sure not to internalize the bad stuff.)
Secondly, you can contribute to an open source project. Don your tough exterior (you know, to protect your sensitive, passionate interior) and get ready for the unwashed masses to weigh in on your handiwork. It's like crowd-sourcing code reviews. You couldn't pay for that sort of feedback even if you wanted to.
Thirdly, you can participate in testing or code reviewing open source software. In addition to doing humanity a service (unless you're load-testing the next script kiddie bundle), you'll get a more hands-on experience in reviewing code than you do just by reading it. This is a great way to practice reading code and to learn how implementation decisions impact readability and testability. As we all know, reading code is a much bigger percentage of our jobs than writing code.
If you're looking for a place to start picking open source code bases, Summa's very own Ben Northrop has a great page that compares some open source projects by static code analysis metrics. Certainly not a definitive measure of what's "good code", but it's a useful starting place.
Have you used any of these methods to improve your programming? Would you add anything to the list
With New Years Resolutions looming, I know I'll definitely be adding some [if not all] of these to my career plan. Then, once we hit mastery, the real work can begin! Cheers.

கருத்துகள்

கருத்துரையிடுக

பிரபலமான இடுகைகள்