Previously on CS410P/CS510...

This summer, we experimented with Android. It was exciting (and kind of rough at times). Let's see what the students thought of the experience.

1. What do you wish you had known before taking this course?
• Android. It's new to the instructor and there wasn't much time to learn it before being assigned a project. Not to mention, this course wasn't supposed to be a flipped classroom so we had videos to watch and class lectures to stay on top of everything else.
• I wish I had known more about using Github and debugging with IntelliJ before taking the course.
• How to build Android app, it will save me time to get from scratch to a complete Android app in less than 2 weeks
• More about android development becuase the android project has a lot of different features that required more time than I expected to learn.
• I wish I was more knowledgable about creating web services and android applications. I also wish I knew more about HTML, because I ran into a little trouble with Project 4 when trying to test the web service because of my lack of knowledge.
• I wish I had known how to set up the program before taking this course so that on the first day, we could work on that to work for everyone.
• I wish I had known the projects involve a lot of command line parsing (and a lot of time!), and that you should get that right in the beginning. Ask David about best practices, review his code before diving in, make sure your command line parsing is flexible in order to incorporate the requirements of future projects.
• I wish I enhance fundamental knowledge about Java, learn more useful APIs like I/O API, database API, web API, etc., and web frameworks etc.
• I wish I had known a little bit more about setting up Java projects (eg Maven). In this course, I liked how the Maven setup was provided to us so we can focus on the Java aspect, but I wish I had learned in some other previous course/experience how to set up a Maven project on my own (for future use)
• The time it would take. I thought since I had some background in programming applications in Java, it would be fairly easy. However the assignments had a lot of detail and missing requirements could be easy.
• Nothing!
• I guess to start the projects as early as possible, though I usually did. It would have been a good idea to set reminders for the quizzes, POAs, and surveys as those can slip by.
• More about the standard libraries in Java, I spent a lot of time researching about what would be the best ones to use for my projects
• I wish I had understood how much of a time commitment this course would be prior to signing up. It probably wouldn't have changed my decision to take it, but nevertheless it would have been nice to know.
• There are a lot of things that I wish I knew but I can't think of any pertaining to this course. I feel that I was at a good level where I found it challenging and informative but not so much where it was too frustrating.
• More about server/client/https stuff.
• This class was more exploratory in nature than I had previously thought.
• Knowing a bit more about networking protocols would've helped. Beyond that, I think the class's reputation preceded it and prep material was available (and made known) plenty of time in advance.
• 1. Git (not basic commands, but more advanced stuff: merge vs. rebase, etc. It was needed in Project 4. 2. A little more practical exposure to Java programming. 3. Also, more familiarity with Android app development would help as well. It is highly complicated stuff, and 2 weeks toward the end of the project is hardly enough for it.
• I wish that I was familiar with Maven/Gradle and had more experience with an IDE. But that's exactly what I got out of this class, so...
• The answer to life, the universe and everything
• Nothing, felt prepared.
• I wish I had known more about good testing strategies and tools. The course does a good job of covering test driven development, but at times I could be intimidated by not knowing the best way to go about testing something. Especially when it involved more complex operations such as working with files or networking, for example, I felt a little lost. I also wish that I had more experience with android, as I think that would have helped out a lot getting started and knowing more of what was necessary for the last project. This is especially in regards to the different components of an application, how data is handled, and the lifecycle in regards to switching activities and fragments.
• general concept of test driven development, I haven't had much experience with TDD and it was the part where I struggled the most. BUT, the course website as well as youtube videos were super helpful to get me through this course.
• Maybe more experiences on some simple java codes which can make my projects go quickly.
• Nothing, I felt adequately prepared.
• I really wish I had more of a background in Object Oriented Programming before taking this course.
• Maybe git and github. I was not very familiar with git/github. It took me some time to work on it, and then after that I started to working on what we leanred in Java.
• I would like to know more about Java standard library and Android stuff.
• I knew absolutly nothing about REST before coming into class, and I think that was a mistake. It made project 4 very hard to even start, let alone finish.
• I wish I had known a little bit more about the build tool Maven. About 75% of my troubles in this course came from trying to debug maven. The rest of it would be familiarity with the intellij platform - it is so powerful and many of the IDEs that JetBrains makes share many tricks, which can save boatloads of time doing menial tasks.
• I feel like I wasn't missing any important prereqs for the high level /source code related stuff. This class, however; reminded me that I need to learn more about project structure, project building, project dependencies and all that stuff. I will go through the screencasts for Maven stuff during the break.
• Overall everything was provided well during the course but I wish I had known a little more about using maven before taking this course just so that building and working with projects would be a smoother experience
• How to use package/dependency managers like Maven/Graddle. Getting setup with Maven especially was a bit of a pain but I'm glad I learned how to do it as I'm sure I will see them again in the future. If I had know these things before hand, I would have gotten up and started a lot sooner I feel.
• The projects are very challenging. I have to spend a lot of time to learn new knowledge.
• more Java. i would like to say i was so beginner in Java, and if knew more Java i will be more successful.
• I didn't know any java, but that wasn't really a problem. It would have been nice to read up on java classes and class hierarchies a little bit more so I could have a better understanding about some of the issues that I ran into in terms of casting or the types of objects. I read the lecture notes on this subject before class started and listened to the podcast. But I still feel a little fuzzy on these topics.
• That we would be make an application and learn another language xml. Still mostly java i just have a hard time adjusting to new languages or environments, like android studio. I spent most of my time on the ui because i had learn how to make it.
• Wish I'd known more about client/server. Was stumped for quite awhile on Project 4.
• I wish I would have known a bit more about working with the REST API before taking this class. It was difficult to learn about in the short amount of time we had to complete project 4. This may have more to do with the fact that this is the summer term. Other than that, I felt well prepared for this course.
• Maven and Gradel
• I wish I had been more comfortable with TDD, build tools like Maven, and working with IntelliJ. However, I felt I learned a lot about all of those things during the term and, although I struggled in the beginning, I was comfortable with them by the end of the course. I also wish I had more experience working with Java, but again -- I learned a lot this term and caught up in time!
• I wish I was more educated on all the libaries and API's that java has.
• We're working on Android. I thought it was pure Java.
• Android and better TDD
• I am not sure what would have better prepared me for that actual work, but I know I struggled the most with the Maven errors. I really enjoyed being challenged.
• I would have liked to have had some experience with Android app building before taking the course.
• I wish I'd had some level of experience with mobile development in general. I found it a little difficult to learn how to program UI elements along with developing the application's features since the concepts were completely new.
• I wish I had spent more time in IntelliJ and had more experience with unit testing so I could have maintained good habits throughout the term.
2. What is the most important thing you have learned in this course?
• Java documentation and test driven development. I've never done documentation like we did in this class where we generated a site. TDD was encouraged and we were exposed to a lot of good examples on how to do them.
• I learned about the concept of REST, servlets, request, response and the Android UI that all relate to web programming
• Project 4, it helps me to getting familiar with server/client program Also Android project seems to be applicable to real life
• IDEs and meaningful tests can make the development process way faster and should be always used.
• I got to learn about how to create REST-ful web services and android apps using android studio, which I find to be very valuable. Learning more about integration and unit tests were also a plus, although I did not implement very many in my projects. There were also a lot of oppurtunity to learn some new git commands/Github features.
• I've become more efficent in using the internet as a resource for finding answer to problems that pops up. Also, I've learn how to read those errors without using the internet as I've encounted them so many time.
• For me, the most important thing I learned in this course is how to approach a problem using TDD. Deconstructing an assignment into manageable problems that I can first write a test for, and then develop code that I can prove behaves how I expect, makes the project less overwhelming--and more successful in the end.
• New skills of Java from koan, such as inner class, lambda, etc. and get me started with android development.
• I had always had difficulties with OOP. WIth this course, I became more familiar and comfortable with OOP.
• A lot! But since its "the most important thing": most of the time taking a step back and asking myself: "What are the ways I could implement this?". My initial thought was nearly always a not-so efficient way. Taking some time, or re-visiting a solution, could have saved some time and made my programs much more succint and clear.
• How to read Java-related documentation.
• Working with Maven, some of the more useful Java libraries, Android development because I just started an internship doing it, and unit testing.
• Unit and Integration tests, I feel that these are super important for actual software development but is something we do not get a lot of exposure too in classes
• I feel like I have a better understanding of more advanced programming techniques as well as more familiarity with Java-specific things. Prior to taking this class, I wasn't familiar with concepts like reflection or inner classes. I had only a cursory knowledge of Maven. I'd never built anything in Android. I gained experience with a lot of different things in this class.
• By far it was in using the debugging tools. I have used JetBrain products in the past but now that I am more familiar with the debugging tools I will likely try them for other languanges in the future (I already prefer pycharm to otherr python IDEs). Especially using jetty and setting the debugger so you can follow the code through the client and the server. I feel I have a better understanding of OOL as well.
• Testing. This is the first class I took that explained/gave examples of testing and why its important.
• Learning how to learn API's even faster.
• A handful of development practices associated with a mature programmer that are mentioned in passing, but not emphasized elsewhere. This includes proper use of a full-featured IDE, a debugger, continous integration, and Test Driven Dev.
• Test-driven development id the most important thing I learned in this class. I have heard and used the concept before but int his class was the first time when I truly utilized it.
• Familiarity with Maven/Gradle and getting used to a git workflow using an IDE.
• Some details about the Java SDK, such as Stream classes etc. I already knew about JUnit and Mockito.
• The most important thing that I've learned in this course is learning to work with different tools in general. For example, learning to make use of abstract classes and interfaces from other sources. It also extends to learning about working with testing tools, maven, XML for Android, IDE tools, and more. In this class more than any other I can recall taking, everything surrounding the code that I wrote felt just as important as the code itself. In this way, the course did not feel like it was simply about the Java language, but also about being a developer in today's world.
• Some Android development
• How to work with other person's code and build upon from there to create something of my own.
• The most important thing I learned is how to create an Android app which including how to deal with the layouts, how to change one activity to another, how to pass items between two different activities, how to display the messages, and etc.
• Android Development and large(ish) scale java project development.
• I learned a *lot* about Java and OOP, about IDEs (I had never used one before IntelliJ), about refactoring my own bad code (at least to the point where it's... less bad), about managing unanticipated project issues, about dealing with code issues that are out of my control (like extending classes and implementing interfaces from existing code, rather than implementing a 'better'solution from scratch). I learned that this stuff can really trigger my anxiety, and that I'm going to have to do something about that to be successful in this field (and that's OK, I'm really glad that I know this *now* and not when I graduate or get a job). Oh, and the Android programming experience was a great opportunity - I really enjoyed doing that, and I took a lot away from that. I am really looking forward to doing more of that in the future.
• I learned a lot in this course. Most of them are completely new to me, something that I have never heared about. For me, it is hard to tell which is the most important thing I have leanred. But I am so surprised and impressed that I can write code to get a web service and a small application work. : )
• I learned how to use Java Servlet to handle request/response in a REST-ful application.
• The power of Google when I don't know what I'm doing--and to try and verify that what I found will work before I spend 2 hours trying to do it.
• The principles and implementation of TDD. They are very useful from a narrow perspective (job applications) and a wide perspective (writing "bulletproof" code).
• unit testing & general java workflow in a test driven development environment: I had taken a unit testing class before, but this class was so much more useful in terms of real world application.
• The most important thing i learned in this course is test driven development. I never truly enforced a TDD approach to my programming projects before and the overall experience in this class was very useful. Moreover, I really got to see the benefits of writing reliable tests that act as a saftey net in case my code ever broke. TDD also saved me a lot of time in the long run when needing to refactor my code.
• I would have to say Test Driven Development and the benefits of using a modern IDE for debugging over Vim + GDB. It will be very hard for me to go back to programming in C++ in Vim without some of the features I have grown accustomed to. I also feel that TDD is a natural way for me to program now and will try to incoperate that in all languages I program in. Learning how to adapt our code to a web server and Android were also invaluable and things I likely wouldn't have learned outside this class and gave me real world programming experience and confidence that I can actually develop a program beyond a CLI that we have done so far in school. Learning dependency management etc. in Gradle/Maven were also important, though a bit of a learnining curve. I also learned how important documentation is, especially for things that are new. There are really too many things to list, but those were the most important to me.
• The most important thing I learn is that detailed planning and self-motivation are key for successfully completing the CS major.
• i feel i have devloped my skilles in implementing requirments, searching to solve issues and explorinig new things to make my output pretty.
• The importance of unit testing when making changes to code. The importance of Integration testing to prepare for unknown grading tests which might use bad input to see how your program can handle unexpected input. Also how integration testing and unit testing take a little time up front but they save time in the end. Also, I leaned how helpful the debugger is. I'm not an undergraduate so I didn't use debuggers in the early CS sequence, and I don't have a background in computer science, so I haven't had to use debuggers much. It really helped me understand code that I was trying to use much more than simply reading it.
• ALWAYS DO YOUR WORK EARLY or rather start your work early and dont procrastinate. You should spend at most an hour or couple of hours thinking about how your going to design your program before implementing to save time when writing.
• Probably the knowledge/experience gained from Projects 4 and 5. First time working on a web/REST and Android project so I feel they were very valuable.
• The most important thing I have learned in this course is the importance of unit testing and test driven development. Before taking this course, I have had very little exposure to the concept of TDD, this is an important concept to grasp considering how much we could gain from practicing it in the industry. The instructor did a great job teaching everything about TDD.
• How java works, and probably how to use android studio to develop an app.
• The most important thing I have learned in this course is to be resourceful and thorough when solving unfamiliar problems in terms of looking up and reading documentation, trying different solutions, breaking down problems into subproblems, and being explicit about what exactly it is I am trying to do. I felt that I learned the most from projects 4 and 5, as these were two totally new areas of programming for me (REST and Android) which pushed me out of my comfort zone and expanded both my knowledge and confidence as a programmer.
• I think the most important thing that I learned from this course is the resuablibty of my code and being able to create something great but breaking it down to small iterations to be able to make it more attainable.
• Being good at reading documentation is very important skill.
• organizing projects in sensible ways
• I really enjoyed learning about Android. I will most likely continue to dabble with Android. I am comfortable with Java and that by extension helps me be more confident in tackling Android.
• How to build a Android app.
• The importance of writing well-maintainable code. Due to each subsequent project building off of the previous one, creating a well-designed class structure from the beginning really pays off in the end, preventing you from having to spend time doing major refactors.
• I have learned how to manage large projects with inherited code much better. I am much more comfortable experimenting with things I don't understand and learning new frameworks than I was just a few months ago.
3. If you could give one piece of advice to someone taking this course in the future, what would it be?
• Watch lectures before the term starts to lighten the information load.
• I would say do the projects early on Day 1, especially projects 4 and 5 and also review the screencasts to get started on the projects.
• Try your best and spend all your time for project 1, it will saves you time and make your later projects easier to implement
• Start the android project early since figuring out how to use fragments and views can be tricky, even if there are a lot of resources online.
• If you don't go to class, definately take advantage of the recorded lecture videos. They are extremely helpful and informative.
• Play around with the program before starting the main program, so that you'll have an understanding of how the code works.
• The best way to succeed in this course is to collaborate with others on the projects (in sharing ideas, not code). I completed the projects on my own, and I often struggled. Oh, and start early. If you can get ahead before the term even starts, you'll be better off. Once you get behind, all your projects will snowball since they're dependent on the previous one working.
• It is a very good opportunity to become a professional java developer if you go through all materials and eager to learn more based on materials and projects.
• It's a lot of work, but it's a lot of fun too! In the end, all the work builds up to a final application that you will be proud of.
• Start early. The professor said it the first day of class, and he wasn't lieing. At a high level a "command line parser" sounds easy, but there are a lot of complexities to consider. This class is like programming linear linked lists -- without the linear linked lists. Edge cases abound and you have to think of recursion (but not really). It can be a breeze in some spots, but difficult in others -- start early!
• Just say on top of everything.
• Start things early, set reminders for quizzes etc., shoot for base functionality first in the projects and then clean them up.
• Make sure to start the projects early and get ahead. I didn't feel too much pressure from all the projects because I had most of the functionality done before the weekend it was due and it helped out a lot. But I saw many other people stress out because they havent finished their projects early
• My piece of advice would be to manage your time wisely. It's very difficult to stay on top of everything, let alone get ahead, due to the sheer volume of work. You'll really suffer if you procrastinate. Nothing is too terribly difficult to do, but the homeworks require quite a lot of time to complete (or at least they did for me) and you get a new one assigned each week. So make sure you're managing your time well.
• Watch the videos if you don't stay through the entire class to make sure that what you are getting stuck on wasn't already addressed in the lectures.
• Watch the lecture videos early.
• Get maven set up early, practice effective error searching online.
• Use the community. Go to class. Get on Slack; 9/10 times your question has already been answered there.
• 1. The obvious one: do not procrastinate on the work. It is not a complicated class, but very labor intensive. 2. Learn git prior to the class, will make your life s much easier! 3. Find a good JAVA reading source, personally, I was not a big fan of the textbook, very heavy on tons of theory but a little explanation on practical utilization (in my subjective opinion).
• Start the last two projects early and find partners in the class to team up with and discuss project ideas. Fortunately, the slack channel was quite active, but it's still great to have a friend to talk to when you get stuck.
• Invest in the design of projects 1 and 2, because 3 and 4 build on it.
• Stay on top of things. With assignments, quizzes, documentation, koans, and more, there's a lot to do and a lot to keep track of. It's easy to lose sight of an upcoming deadline. It's easy to underestimate the amount of time that something will take. You might realize along the way that you had questions about an assignment that you need resolved. Doing well requires using your time wisely and being timely about your work. Even if you feel confident in your ability to estimate how long something will take, it's very likely that you'll have a few surprises along the way.
• Watch the Advanced Java Programming video beforehand. It was still very helpful to watch as the course goes on
• The projects take time, so please start as early as you can!
• Don't tarry timidly before embarking on the projects, get started immediately.
• Start brushing up on your Java now!
• There will be a lot of interesting things to learn in 8 weeks.
• Be prepared for a bit of programming
• be familiar with web application as well as client and server side.
• Don't wait until the last second to start a project. Start early. And don't get caught up in trying to make something look really good or try to do something in a really fancy, impressive way when a simpler option works--the less complexity you add in, the better your program will end up being.
• Practice building maven projects on your own. Learn the directory structure of the projects. Stick with TDD.
• Take Advantage of the relatively slow (conceptually) pace of the class and follow the Test Driven approach! I have been whining about wanting to do test driven development for at least a year, but I never have the time. Except the Android stuff, we are used to seeing most of these concepts and I finally got to focus on testing (well at least for the first four project)
• A lot of times I would only give myself a week to work on projects (because I would still be working on the previous project) and that sometimes made the process a little more stressful as the projects got progressively harder. So my advice is to make sure time is allocated in a manner that makes sense for projects that are harder.
• Take this course alone or with light classes like non-cs electives/clusters etc. I definitely would not have had a good time if I took this at the same time as CS 320/333/350, etc. I took this course alone with no job/internship/etc. and still found it challenging to keep up with all of the work, but doable with enough time and dedication.
• It's better for you to learn some basic concepts in android. For example, android activity management and android activity life cycle.
• 1- learn Java before going to this class. This class is advance not regualr class :) 2- do not push your work to the last minutes eventhoug the requirment looks easy. ton of work waiting for you.
• Use the debugger for understanding code that isn't't yours. I thought the rest web application was going to be really hard and complicated. But after learning how to use the debugger and using it to step through the code provided. It made the whole assignment seem pretty straightforward. Secondly, I feel like I sort of hacked my way through type casting and issues that popped up around class hierarchies. In retrospect I think I would have gained more from the class if I had watched the online video notes at home earlier and with greater regularity. I usually watched them too late to be able to apply them to my projects or koans. Because I didn't watch them as much as I should have, I didn't benefit from the koans as much as I could have, so my ending knowledge of java suffered a little as a result. But I didn't really have any trouble completing the projects, so it wasn't a total loss by any means.
• Get ready to master all of java or most of it.
• Start the projects early. Don't wait till the the last minute, especially for projects 4 and 5.
• My piece of advice for someone taking this course in the future would be to make sure to start the projects right away, and to ask questions when you are stuck. Many of the problems that you may run into while doing the projects may not be answered by google, using the resources such as the instructor and their office hours will be a very valuable use of your time.
• Any time you need a new enviornment start EARLY.
• Program every day, keep up on the course Slack channel, and don't be afraid to ask questions! I made a consistent effort to program every single day, even for just a little bit, which keeps problems fresh in your mind and allows you to "sleep on" design considerations, bugs, solving problems, etc. Also, having access to our course Slack channel saved me a TON of time. I would come across people who asked the same kinds of questions I wanted to ask and often found solutions for those questions right there. I would also come across discussions about various design considerations, such as what libraries to use for file I/O or what container(s) to use for storing all of our appointment books. Lastly, not being afraid to ask questions also saves a lot of time and frustration -- sure, give a problem a good effort and try to work out a solution, but sometimes you just need a little nudge to get unstuck and make a ton of progress.
• START YOUR PROJECTS EARLY
• Be familiar with android, and how it generally works.
• Start your projects early and don't forget to do your POAs. -_-
• Be prepared to read documentation to help further expand your knowledge. Not reading documentation limits you to what you know, and not to all the possibilities that are really available.
• Work on your projects quickly and consisely, don't waste time or procrastinate.
• Start early on the projects, or else they will stack up and the work will become unmanageable.
• Start early and code regularly. Problems will arise and they will be confusing so give yourself enough time to take breaks and think about/research the issues.
4. What made you stay in this course?
• Curiosity and I like coding.
• The instructor was very prompt with responses on Slack and I got to learn more about web programming and using the Android API.
• The project not too hard and I got multiple helps from both instructor and classmates through Slack for questions about projects
• Graduation requirements, already paid for it, learned about testing frameworks, android is fun to work with.
• I have some Java skills. I'd like to take it as an opportunity to enhance and improve my skills, so that it is possible for me to apply for a java development job.
• The projects were really cool. I like how David integrates the use of different applications and the learning of other new things into this course besides just Java topics (i.e. REST and android studio). David is also very thoughtful of us students, being readily available for questions and posting very useful resources. He truly cares about our learning and success. This class is also easy to follow and master rather than so hard that I regret all my life decisions.
• I mean, I paid to take this class, so of course I'm going to stay. But honestly, I stayed because the course is well structured and really does focus on relevent topics for computer science.
• I'm not a quitter.
• I wanted to become more familiar with OOP. Java is a widely used language, and I thought this would be a good course for me to take to get familiar with OOP.
• A lot of things. The teacher was super helpful (perhaps he has programmed a robot to answer for him on slack and email?) and funny. The material was challenging -- but the "right" type of challenging that taught us important concepts and syntax of Java. The course also taught Android... which I didn't originally know, but have always wanted to learn.
• The class gets to the point in terms of assignments and the materials being learned.
• I've never dropped or failed a course, and I'm not going to start now. I also enjoyed the projects, especially having previously taking a math-heavy term.
• Great lectures about content which I thought was actually going to be useful when getting a job.
• I learned a lot and enjoyed the programming assignments.
• I am not going to throw away money, regardless, but it was informative and I am a big fan of classes with structure and scaffolding. Classes where you show up the first day and the professor tells the students that they will be deciding what they do for the next 8-10 weeks in groups are anathema for me.
• Bad refund policy. Help on slack and late turn in dates help a lot, especially with such a short class.
• Interest in the REST and android stuff towards the end.
• The only time working this hard is distasteful to me is when there doesn't seem to be payoff. This class has tangible payoff in terms of applicable skill/knowledge. It's much more transparently fruitful than most other classes. I also started an internship, in the second week of class, in which I was using almost exactly the suite of skills we honed in this class, so there was instant gratification as well.
• Interesting and practical subject matter.
• It all felt very practical and like "real-world" industry concepts/practices. Coming from the 300 level theory classes, this was a breath of fresh air.
• This course was actually cool, but also stayed because I want to graduate and maintain my pristine GPA.
• I was initially intimidated by this course's workload. I felt that it was a lot to take on and I felt a lot of ambiguity in the assignments and expectations. I decided to stay with it because it also seemed like an interesting course that would allow me to grow as a programmer and develop new skills and be more comfortable with the skills I possessed. Over time, I got more of a feel for the course, its expectations, and how to do well, and that put me more at ease in staying in the course as well.
• Quality of the course in general was good, to name two things: 1) feeling of achievement that I finished each project each week by myself as they were all individual work, but friends who were super helpful when discussing about the project; 2) Slack channel - it was great communication channel with David as well as classmates, especially to tackle each project. (Of course I thank David and my classmates for great questions and quick answers).
• The eager to learn new stuff. It forced me to learn things in a short time.
• I wanted to learn Java and the projects are super helpful.
• I was learning a lot, I enjoyed the class (if not the Projects), and I'm stubborn. That was a recipe for me staying the course!
• I like to take programming intensive courses, and Dave has been very supportive and provides detailed information about everything we need from the first class. Therefore, I believe this would be a good course to stay in.
• Graduation
• this course provided me lots of example of unit tests, which is great for my future programming.
• I wanted to learn more about the Java environment. I definitely learned more about the Java environment.
• I really liked learning about the Java language! I use it every day at work and am really starting to gain a more in-depth appreciation for how it actually is a fun to write programs in.
• Easy to follow & revisitable lectures(screencast), Android Stuff, useful programming patterns (testing, exception handling, ide shortcuts ) plus I like Java.
• The biggest factor that made me stay in this course was I really enjoyed the weekly projects and it forced me to actually code physically. A lot of classes focus on theory and have very little actual coding in the class which really hinders ones ability to actually code when the time comes to it.
• I learned a ton and haven't had to drop a class yet, so wasn't going to start now. I also love Java and know that alot of things I learned in this class would be helpful in the future and I likely wouldn't gain this experience otherwise.
• I take it, so I have to finish it.
• you. The amount of help you provide. me. want to learn to be successful.
• I like the course because it was based around programming assignments, which I like more than content or theory heavy classes. The quality of instruction was great, which makes it a better course than others within the department. The assignments seemed heavily scaffolded so it was never really overwhelming, even for someone with no java background.
• I love java and this class just reinforced my motivation to keep using it. It has been my main language but after taking this class I see how powerful it really is and will continue to keep using it.
• A desire to advance in my computer science career.
• I have always been a fan of the Java programming language. I liked this course because it challenged my knowledge of Java, forcing me to learn/do things that I may not have been comfortable with yet. It allowed me to push my boundaries and realize there is much more to the language than I had previously been aware of.
• It was fun. Even though David started every class with "Wish more of you had showed up", I really was able to make use of his videos. It helped being able to watch, and rewatch the videos to learn.
• I came into this course with the intent to do a lot of programming, especially every single day. I stayed in this course because mama didn't raise no quitter and I had faith in my ability to overcome unfamiliar, challenging problems and succeed. The Slack channel was a big part of my success this term, especially for saving a lot of headache and wasted time.
• The challange, I really liked being able to start in a class with little knowlegde and come out of it feeling really confident with JAVA and actually feeling like I learned something.
• Learning Android, learning about java development, and test driven development. Test driven development has opened my eyes to how easy it is to debug bugs once you deploy it.
• Mostly the cost of admission and the ability to practice Java. Also, I found the lectures generally informative.
• The instructor. Seriously! I have enjoyed learning TDD, but the instructor helped me enjoy going to lectures. I liked the different learning styles, Koans, Katas, group coding, and the energy. Thank you!!
• I paid good money towards the class, I stayed to make my investment worthwhile.
• I enjoy programming in Java! I think there should be more Advanced "insert programming language here" classes. I really wanted to gain the experience of delving deeper into a language and getting to learn features that one wouldn't necessarily use in other higher-level programming classes. Java is also widely used in industry so I find the material relevant to a real-world application.
• I had fun! The work was interesting and the projects were a good balance of challenging and educational but not too intimidating.
5. If you had to remove one lecture from this course, which would itbe? Why?
• Not to be rude (I really do enjoy the class) and while I am really interested, I would unfortunately remove the Android lecture. I'm almost certain everyone is watching YouTube tutorials or searching on Google for answers. Since we have an Android project affecting our grade, our focus is on getting that done so that may be why people chose to skip class to get the answers they need. Time is equally important.
• I would remove the Code Katas and Coding Dojo since we don't work in pairs or groups for the project. If the project were done in groups then maybe these lecture topics would be more relevant.
• None
• The last one, though I wouldn't say remove it just have more specific material prepared to present about android like good practices to follow when creating an applicaton (ex. using fragments).
• I think the lecture on creating the unit/integration tests for Project 4 were not very useful. I mean the concept of test development is good, but since they weren't required and not always applicable to how we set up our own programs, I didn't really pay much attention to that. I wouldn't necessarily remove the whole lecture, but trim it down a bit and make more room for other content or a deeper explanation of the Servlet class or something. I also didn't know that we didn't really need the Messages class until someone else told me later that we could just get rid of it.
• I don't think any part of lectures should be removed, but I don't think pair pragramming in class is necessary unless we have team projects.
• I would have to say one of test driven development classes. The reason why I think so is because there was already other lectures that used test driven development and we could just rewatch the lecture again if we don't understand it.(Not talking about Test driven developent for website and android studio.)
• The last lecture. I would prefer that you determine the content based on your own experience and interests than have the students direct it. You know the practices used in industry better than most (probably all) the students. I'd like to hear what Java skills/concepts you want software engineers to know when applying at the junior/mid level. What types of Java-related questions might you ask in an interview? What project management tools will we see in industry? Should we learn more about Maven? Are there other technology that might be useful to know about, or do a tutorial on? I want to learn things that are most useful in the real world.
• All the paired programming stuff. We never really used it much, but it was described in great detail/why we should use it.
• Hmmmmmmmm. This is tough. I think some of the Maven stuff was good, but not necessary for this course. Specifically programming a parent pom was not much used in my structure as I didn't think that recompiling my previous programs (or checking if they needed to be recompiled) was a good use of my CPU time (hehe). The travis piece was also really cool! But unfortunately it was not able to be implemented since it only worked for me if I turned my repo to public (perhaps there is a way I didn't find around this).
• I think each and every lecture covered an essential part of Java. Thus, I believe that no lecture should be removed.
• I can't think of any, the course was pretty concise (especially on the shortened summer timeline). I think removing any of the lectures would have been to our detriment.
• One of the android lectures. I liked the android project and the fact we went over it. But I feel like an entire lecture on it was excessive especially becuase there are so many good resources for android development out there.
• I wouldn't necessarily remove this lecture, but the lectures you did on Android felt to me like you hadn't spent enough time preparing. Obviously, you were brand new to Android and the next time you teach it, you'll know more. But I definitely would advise you put in the time to make sure you're really familiar with the topics you'll be covering. I would also recommend doing a run-through of any coding examples prior to demonstrating them to the class, because a large portion of the class time was spent watching you try and debug your code. This felt like a big waste of my time, and I ended up getting very little from the lecture.
• I didn't find the second to last lecture very informative. Watching someone as skilled as you make mistakes and debug was helpful in the previous lectures, but that class could have been spent reading myself.
• None.
• Whichever week we spent the first half of class all downloading android studio. It might have been more effective to have folks download it before hand via a mass @everyone on slack so that we could get to the android stuff faster.
• All else being equal, I'd remove the pair-programming bit. I actually enjoyed it, but I choose it because it ended up being short-lived and also because it seems uncommon in practice (though still valuable to know about.) If the thread of pair/mob coding were to be maintained for a couple more class periods in future iterations of the course, it would probably still be worthwhile. I know time's at a premium though.
• I am not sure about which lecture to remove, but I have a suggestion about which lecture to adjust: I would make an entire 1 class dedicated to working on a specific project (something small) but via par programming, from the beginning to the end in 1 class. In that case, we can 1. brainstorm in pairs and 2. code in pairs
• Well, you actually did skip it but I think the mob programming is the least beneficial. I'm all for pair-programming but I think more than 2 or 3 programmers whacking at the same problem is unproductive.
• The lecture where we talked about breakpoints and using a debugger. Because everyone (hopefully) should know at this point.
• I think they were all helpful
• The quizzes. I understand that having conceptual knowledge is important and being aware of the different libraries and their capabilities that java offers is, of course, quite useful for knowing how to write good java programs. But I think the best way to learn and evaluate this is through practical usage. I got a lot out of doing the projects, but the quizzes felt like a side thing that didn't really benefit my learning, especially since the quizzes covered largely what we were already doing in the projects. I think a possible alternative would be some kind of research activity -- where the student could go into the java documentation and learn about things available in the language that aren't being covered by the projects.
• I like each and every lecture. If I must pick one, I would let go pair-programming portion, because it seems this is something you can also learn better outside class (when working on projects with friends or when working for company) although it was fun class!
• Maybe Week 7 about "More Android". Instead of talking bout the test in Android studio, I prefer the topic about the storage In Android which including internal and external storages, I think this may help us more on the last project.
• The seventh lecture because there wasn't enough prepared for a full lecture.
• I felt like they were all valuable - I watched almost all of them again. I would say that if lecture changes had to happen, additional focus on figuring out how to write unit tests would be appreciated by those who haven't done TDD before. I would also say that it would be good to add some additional Android resources to the website for that portion of the course. I know this is the first time this has been offered as part of the course, so I totally get not having them, but it did add a layer of complexity to that part of the assignment not having anything much beyond developer.android.com's libraries. And that was OK if I already knew what I was looking for or looking at.
• I am not sure about this. Maybe the first class, the git/github part could be students' own responsobilities to get familiar and know how to use it for further learning in this course.
• I think they are all good. And I may remove dependency injection, since this lecture is pretty complicated to understand.
• I would have skipped one of the lectures where all we did was the Student Project 0, and used it to talk about REST some more.
• The initial lecture about Android. It didn't go so well and was a lot of live debugging.
• I don't know if I would remove any lecture from the class but I would definitely reduce the first three assignments into two. I think the transition from second to third assignment was a little trivial. Four Assignments (A warmup project+Parsing FileInputOutput project+ Servlets project + Android Project) would make it better!
• I felt like one of the android lectures could've been removed because at that point the amount of information coming in for a new technology was a bit overwhelming while simultaneously working on the previous project which involved REST api. It might've been better to consolodate both of the android lectures into one broad lecture.
• I wouldn't remove any lectures, but I think future classes will benefit from a more refined Android lecture(s), as we were the test class for this as it was new and I know things learned in this class will help in the future (not having the entre class download/install Android studio at once, for instance).
• Every lecture is necessary. However, if you can give a detail lecture about android activity management and android activity life cycle, the lecture will definitely help me.
• I'll say nothing to be removed. From project stand point 1, 2, 3 is importent to make you understand Java. Without 4 & 5 will be boring. I enjoyed Android one very much even i was not able to complete all the requirment. but now i feel i have the capability to do what i want in Android.
• Did we have two or three lectures on android? We could have done one less. Although I understand that the reason we had the number we did was due to some unforeseen technical challenges associated with teaching android for the first time. I would have appreciated some more explicit instructions about java class hierarchies, casting, or collection classes in place of some the time spent on android. But maybe I just needed to do a better job watching the videos that were provided.
• not sure I think all of them were helpful in their own way.
• I would probabaly remove the lecture with the least amount of views for its screencast. Off the top of my head, maybe the last lecture. Didn't feel like I got much from it.
• The lecture about functional programming is one that I feel could be removed from this course. Much of what is covered in this course is also talked about in CS320, and seeing as how the concepts taught in this lecture are not directly applied to any of the projects in this course, I feel that the time allocated for it could be better used talking about something else.
• None of them. If I had to number 4, because I put it in a random number generator and that's what I got out of it. This class really helped me understand Java, and was fun to boot.
• I would say the very last lecture (week 7) because it didn't have as much content or purpose as the other lectures. I think that in future iterations of this course, your Android materials will have been further developed and refined to where that last lecture will be more substantial and useful. However, I still found the last lecture very useful because we discussed data persistence and a bit of file I/O which, for me, were the hardest parts of Project 5.
• Nothing, I felt everything taught in this class was usable. But I feel like if we took some time to talk about writing our code in templets style. I have always wanted to learn it in a class and I think learning this concept in the first week of class would have been super benefical for both the class and my future.
• All lectures were good, and informative. It would have been nice if you understood Android better, and gave suggestions on what we should use. I spent alot of time watching tutorials, reading documentations to get a good understanding of how android developement works.
• The lectures on basic Java concepts were somewhat tedious, but only because I've used it before.
• I am not sure what lecture to remove, but I would definately recommned, having the class download the Android Studio IDE, before class. We were all eager to learn at the same time, so we all just waiting in the downloading queue. I would've have liked to definately liked to have learn more TDD with Android.
• This is a little bold, but I would have short, consise online lectures. Why? Personally, this would have helped save time and just learn what I need to before doing the project.
• I would remove one of the Android lectures. I think the material could have been better streamlined with better formulated examples instead of spending class time installing the software or digging through documentation.
• I feel like the java language APIs language could be condensed or merged into the intro to java lecture so more time could spent on OOP concepts or trickier things like web applications/android.