Previously on CS410J...
Another record-breaking number of students who had some interesting things on their minds...
- What do you wish you had known before taking this course?
- I hadn't really used intellij much before this class. Not knowing of some of its abilities may have slowed me down for the first couple projects. The coding lectures with the keyboard shortcuts displayed was really helpful.
- I hope that I can learn more about the basics of Java. Such as the use of collection. There is also the use of mvn, this is my first time using mvn to run my program. If I learned those before it will very useful in the first four projects.
- Have some knowledge of client and server because there was a period where I was stuck on how to even start on the assignment.
- This is a really hard question. I didn't particularly struggle with anything very much, but I would answer with probably mocking.
- That setting up new working enviroments (maven) may be a quick little 30 minutes thing. Also just for other classes I wish I would have known about GWT, its awesome.
- Intellij macros and shortcuts
- Generalize your project! I spent a chunk of the course thinking we were only dealing with a single usage, but eventually learned that my file needed to support multiple stored calls, etc.
- I didn't realize the course was going to be structured like a flipped classroom. I tend to learn better in a more traditional setup. Would have been good to know that ahead of time.
- I hope I had known more about the front end stuffs like css, js and html.
- I wish I knew how to use maven and how to unit test before taking this course.
- Unit testing and more familiarity with HTTP
- I wish I had know more Java and TDD. However, I do not think that is the fault of this class, but more of PSU. We do so much in system level programming that we do not get a chance to write more developer level code.
- I wish was more knowledgeable about IntelliJ setup and maven. It was difficult to get going on Project 1 because of it.
- Not much, a lot of what was presented was presented pretty well IMO.
- Exactly how to use Comparators.
- To run my server locally rather than through babbage. I think I saw the server being run in a command window in a screencast and assumed it was through the psu linux server and not locally.
- More about Mocks, generics, lambdas and when to use them and anonymous inner classes. Maybe more exposure to Java in general. We barely get exposed to it elsewhere.
- Some UI development and CSS and HTML. I spent a long time on program 5.
- Project 0 was a good refresher.
- To not bother with trying to set up a local environment and just use the lab computers. Either that, or try setting up the local environment a week or two before class actually started.
- I have had some experience coding in basic Java and that was enough to enjoy this course. So there was really nothing I wish I had known before taking the course.
- Knowing Junit / testing APIs would have made testing go much faster.
- I wish I had known how the projects were going to be tested. For example, I disallowed numbers in customer names, and then I failed every test that used test1, test2, etc. as input.
- I wish that I would have known to use java.util.Date on the first two projects. It would of also been nice to give the advice of seperating out some sort of validation class that would universally work with all the projects.
- Only basics of Java Classes help through the class.
- How the assignements are graded.
- a little more fluency with java and java style. I had to look up some java keywords before I started programming.
- I wish I had greater familiarity with java in general, namely with the attributes of commonly used objects and the varying ways they can be compared. Doing the koans was a good introduction to this, but more time with java in general would have saved me some annoying bugs.
- The class was as expected.
- I wish I had some web application experience. When I first start the project 4, it was so confusing. I watched the vedio like 4 times. Finally, got comfortable about it. But I am glad that I learned.
- I wish I can know more about intellJ which can help me code more efficiently.
- Environment setup and associated IDE setups would be an absolute nightmare. Too much can go wrong, and it will completely pooch your ability to do assignments and nobody will know whats wrong.. Its like Operating Systems all over again..
- The time to setup a project before working on it tended to be longer than usual due to lack of knowledge with Maven projects.
- That there is a giant leap in workload between project 3 and project 4
- Although I had completed the prequisites for the class in CS202 but Java was mildly touched and so my basics were not very clear. It has also been a while since I did 202 (Last Summer). If I had prepared a bit more on the basics of Java then things would have been a lot more fluent for me. I acknowledge that I am a slow learner and creating an advantage by making a strong base is imperative to learn high complexity topics.
- Just that I had a more solid foundation with Java.
- Some basic Java concepts definitely would have simplified the projects.
- I wish I had worked with REST, GWT before and had some more experince working with server-client programming. But, I am still gratified that I learned them by practically working on it not just theoretically.
- I don't think there is anything I wish I had known. I think my expectations given my previous experiences with Java matched up to the class expectations pretty well. What I didn't know was being taught the class anyways.
- I could have used more familiarity with Java.
- I wish I had more experience with Java programing.
- I wish I had more familiarity with Java. The assignments took me quite a long time because I didn't know the language at all before starting the course.
- In Java, everything is a class.
- That this class should be called Advanced Programming using Java. Only half the material is about advanced Java topics and the other half is about other topics, that are interesting, but wasn't what I was expecting.
- I don't have much experience with object oriented programming in general, and I think I would have benefitted with more practice with them in general.
- More about java Programming especially how Java 8 and onwards has made things(syntax) easier. Lot of things in Java Koans looked new but was fun to explore and learn.
- I think I came in well prepared with a background in C#. I just had a problem with time management.
- I wish I had more experience with the syntax of Java. When I've used Java in internships, I've followed the language patterns of the service I was working on. I would have benefitted from grounding myself more in the fundamentals of the language.
- What is the most important thing you have learned in this course?
- That there are a lot of tools that leverage Java out there, and a lot of resources for learning about these tools. The look into GWT seemed to only scratch the surface of the capabilities within.
- I learned so much from first three project. I think they are helping me build the foundation. Originally I was just a preliminary learner of Java. I am not very clear about a lot of knowledge. But after finishing the third project, I feel that I have a lot of Java knowledge that I didn't know before. Such as the use of Collection, transfer Collection to ArrayList and dump/parse file.
- client/server api and using the google tool kit
- The importance of having tests that ensure the behavior of your application.
- Probably test driven development, its something I have done very little of before. It will be very helpful and ave me quite a bit of time in the future.
- Tie between unit/integration testing, and usage of github repository.
- The importance of building unit and integration tests with your code. It helped to provide so much confidence in my code for the projects.
- Unit test absolutely.
- The most important thing I learned in this course is unit testing and TDD.
- Unit testing
- Java! Seriously, I really like this language and Intellij is awesome too.
- The most important thing I learned was the importance of test driven development. Making sure the test fails first is key to making sure everything is working properly in the end.
- Be patient and have many sources to confirm if a build works or doesn't.
- Interfaces are really useful.
- Learning more about the client/server relationship. Most classes so far have not given me an idea on how to create and application that can be seen outside of an IDE, so when we can see something that I can open in a browser it is very interesting to me.
- How to be better about writing my own tests for my programs. It helps to see the effect on those tests as you change the code base and some unforseen side effects occur.
- Maven tools and the web development part on program 4 and 5. How the back end communicates with the front end and how the client on the website communicates to the server.
- test driven development
- I have gained solid working knowledge of the Java programming language and perhaps more importantly gained greater understanding of the object oriented programming paradigms.
- The most important thing I have learned is about test-driven development, specifically how to write automated test. In addition to it, I have also learned about REST API, Google Web Kit.
- TDD techniques (e.g. Red, Green, Refactor); lambdas / inner classes; reflection; functional programming in Java. I wish we had gotten hands on learning, and more in depth lectures / examples on reflection. Seems like reflection is the key to building tools in Java like Junit, Servers, etc.
- The main thing I learned was just general coding practice. I came in as a junior Java developer, and over the course of the quarter strengthened my skills. More and more I am writing many lines of bug-free code that I wasn't able to as consistantly before this class.
- Probably the web application development, and a general deeper understanding how web dev works.
- I got my OOPS concept and REST API clear to a great extent.
- REST API
- I used to think that it was "cool" to be able to write code that touched multiple fragile components without writing unit tests. Now I understand that this way of programming is dangerous and leads to a hectic development process. Unit testing and (when approperiate) TDD is a great tool for software development. I wish I tried TDD earlier. I'm not going to blindly use it for every programming task but I am beginning to understand its usefulness.
- The experience implementing common application patterns has been invaluable. Also, project 5 is the first time I will have implemented a user interface, and has made the prospect less daunting than it was.
- How useful IDEs can be and also brushing up on different Java aspects
- The most important for me is that I learned how to build REST and Rich Internet Applications.
- Using of advanced java language, and web application.
- Object Oriented concept of Java and be used to maven project
- Client/Server interactions, using both request/response, as well as GWT frameworks. Everything else was a refresher.
- Using Maven to create Java applications, GWT, Test driven development and writing unit tests.
- General advanced Java skills and programming techniques
- Although our course covered a lot of different topics but I beleive the most valuable addition to my skillsets would be writing unit testing along with coding. I would consider my coding skills to be average but my testing skills were almost zero as for some reason I have the tendancy to avoid them. This class helped me to get a little more closer to testing along with coding which is an invaluable skillset for a coder.
- Test driven development has been really bennificial.
- Google web toolkit and how we can make use of the classes in Java
- I had very little experience working with java, but from this class I learned a lot more on Object Oriented Programming, collections API, client-server programming. But GWT, REST, Maven were pretty much new for me. And also test driven programming, documentation, etc
- I think probably the work with tests was the most useful, especially compared to the approaches in other classes. Only one other CS class that I've taken here has had us use testing. It can really help with one's confidence in the code one creates, and at least for larger projects, cut down on personal testing time.
- Tools for implementing an internet application.
- I learned a lot of the basics of Java programing. I also feel that I learned some more advanced topics and I am at a good spot to continue with my understanding of Java in a more applied manner.
- This course was great for getting some familiarity with backend web development. I'm having to learn about writing RESTful services at work and this class offered a nice, approachable introduction to REST/full stack web dev.
- Working with OO program design.
- Learning how to use new technology and software like Maven and GWT.
- I really learned the value of testing and the advantages of test driven development.
- Not to have any hard logic in the code and make it easier to rework on. As the projects were built over the term, it required lot of rework and refactoring of existing code to make it work for the requirements of the new project. It was an eyeopener and made me think about coding in a simple and elegant way and not overdo the logic.
- Configuration. That might seem trivial, but this was my biggest issue with Java in the past. I never could really get projects off the ground because the setup was very difficult.
- The most important thing I learned in this course is something I have suspected for a while--that to learn a new language well I have to learn it in practice and in theory. This class pushed me to round out my knowledge and to recognize that I'll need to do the same with future languages.
- If you could give one piece of advice to someone taking this course in the future, what would it be?
- Try to stay ahead of the projects. Even working on it the weekend before they're due has risks if you encounter an issue that isn't easily resolved.
- I would suggest them know something about web java and GWT. Although only the lasr two projects covered those topics. But these two are Java knowledge that most people are unfamiliar with. And the scores in the homework are also high.It takes some time to learn. At least for me. So I suggest to understand these two topics.
- Start on your project earlier because the project gets harder and harder to do. If you don't work on it early you will fall behind and get stress out.
- Be prepared to do lots of busy work.
- If you have any questions go to the office hours. It was always incredibly helpful. Also do not procrastinate on project 4, just because its due a week after the previous project, does not mean it will take as long as the previous project.
- Pay attention during the project 4, it was the most confusing and difficult.
- During the first week, try to finish as much of the koans as possible. The koans help introduce java concepts that are useful later in the course.
- Check the Community and Screencasts often.
- Be prepared for a lot of outside research to complete projects.
- WRITE YOUR UNIT TESTS!
- I would recommend to start the projects early and to read over the slide decks. A lot of the skills needed to complete the projects are in the slide decks.
- Make sure they have used IntelliJ and have some familiarity with HTTP and client/server communications.
- Be patient and have many sources to confirm if a build works or doesn't. Test for small and stupid cases - they can save you lots of headaches down the road.
- Leave yourself time to refactor your code so that you have better code to work with before you have to build on it for the next assignment.
- Be active on the Google Plus community, or join a discord/slack/other group so you can help and get help from others.
- Don't wait to get started on projects. They get progressively harder and if you don't leave yourself enough time you will regret it when the deadline approaches.
- Learn a bit of UI, CSS, and HTML before you take the course.
- Find someone to work on assignments together.
- Start the projects early and don't get behind.
- Allocate more time for development; it takes more than you think for full implementation.
- I will suggest to always start your projects as early as possible.
- Start your projects when, or even before, they are assigned. You should already know this.
- Read the project requirements very carefully, and don't add uneeded features that will only mess up your project.
- * Use the Date class early! * Make a validation class.
- If you want to get clear of how web servlets works and basics of JAVA, it is the best class to have.
- Start project ASAP
- Give TDD a try!
- I would advise a prospective student to make certain they have substantial time to devote to the class because, although the individual programs are not especially complex, implementing them in a relatively unfamiliar language can make them significant endeavors.
- Initial IDE and computer set up is important and also incremental development is important
- Know a little bit of web application before the class.
- Learn more about maven
- Get your environment setup and tested immediately.
- One advice be to research and play around with Maven build tools so that you are familiar with how things should go when setting up your projects during the term. It'll save you time and headaches. Another advice is to use the Java documents. They are your friends and help in designing and development of your projects! Last and most important advice is to manage your time when doing the projects. Don't leave it till the last second to start working on them. They will take time to design and implement.
- Get Koans done early, they help a lot with the early projects and gaining a better grasp on Java in general
- My advise would be that this course is a must for all junior level coders as this brings in the real world industry concepts of web applications like REST, GWT etc. I had no clue what these jargons were before this class but now I can atleast relate to the topics in a much better way.
- Same as any other programming course, start early, ask questions, don't stay stuck on something without reaching out.
- Most important and only advice is to start working on the projects as early as possible because no matter how much time you have it will never be enough and do keep track of the work you do by documenting it from the very beginning which will be very helpful in designing, implementing and in testing, and you can determine easily what should be your next in the project. Apart from that, try not miss any of the lectures and if you do miss, make sure to go through the lecture videos.
- Don't start projects too late. Sometimes difficulties can pop up that you weren't expecting, making a seemingly simple project take longer. It also helps to have started or at least looked at the project instructions before they are discussed in class.
- Start the projects as soon as possible.
- Make sure you have a solid understadning of some of the basics of Java, it will help with the beginning of the course.
- Learn java before you take the class.
- Projects will take longer than you think they will. Start early!
- Start early on the assignments. They are not hard but usually take atleast a day to understand what you need to do and a day to actually program it. Invest that time early on since the assignment do overlap.
- Taking the time to make unit and integration helps are really useful while building the code. Also, I would advise them to carefully consider edge cases when creating the tests.
- Start early on the projects and have the code reveiwed by the professor before final submission.
- To have fun while coding
- Stay on top of all the course work, surveys, and quizes.
- Don't neglect the didactic matieral--the pre-recorded lectures, lecture notes, and textbook were all very helpful in the later half of the cousre. Also the class discussions and screencasts of those discussions were crucial to doing the projects well.
- What made you stay in this course?
- Because I signed up for it? While challenging, it certainly wasn't difficult enough to warrant dropping.
- To be honesty, I was a little scared when I started on the first project. I felt it so hard, I may not be able to finish it. But with the help of my classmates, I completed my first project. It be more convenient for the following projects. And also I got my satisfactory results. This is the most important. It is worth mentioning that it is very useful to be able to re-submit homework for the improvement of grades. Modify the program if you know where you are wrong. Then hand a more perfect project.
- It was fun, I was able to use some of what I learned in class at work.
- Ummm. I never considered dropping. However, I chose to take this course because I'm very tired of the PSU computer science cirriculum being so heavily focused on theoretical concepts. I wanted to take a class that actually was tangible and related to why I am acquiring a CS degree.
- Because I wanted to learn more about Java
- Learning about all of the different uses java has (plus I love programming in java), and how easy it was to get into contact with the professor and TA's. I am a big fan of the google plus page, it was pretty helpful. Even though I had no idea people actually use google plus. Also the assignments, they may have stressed me out a little with them being due so soon after one another (I feel this course would be a lot better as 10 weeks), they do a really good job of covering a wide variety of material. I was really happy to learn we would be doing a client server application.
- Instructor contribution to the course was excellent, the projects progressed in a way that made me feel like I was learning/growing incrementally. Nothing was either overly difficult or easy, I appreciated the ability to communicate/resubmit regarding test results and minor errors.
- It was an interesting course and I like Java development.
- Learning coding in Java is fun, need to take Capsone next term also.
- There is a lot of good information about testing and integration of complex programs. I also need to graduate in a set amount of time and can't afford to fail or drop classes.
- I appreciated that we were using relevant and practical development practices. I also liked the focus on programming rather than studying for exams.
- I felt like I was really learning how to write programs that did stuff. They were not toy programs (yes they are still very basic but they did stuff besides some academic idea). I also think Dave is a really good instructor even if he goes too fast while coding.
- I've done 2 interships that were Java specific and the tools we learned in class were exactly what we used at those companies (maven, ajax, mockito, etc.). I wish I would have taken this class before doing the internships because I already would have known what was going on. I stayed in the class because I know how important this stuff it to know in the "real world".
- Clear lectures with good content.
- I had no reason to drop it.
- I first joined the course mostly because I needed a programming intensive CS elective. I stayed in the course because of my interest for the later projects and learning more about developing a program the interacts with a server.
- I think that a deeper understanding of Java makes you more likely to be hired, and more marketable in general when you go to enter the workforce. I felt like my skills in Java in general were being sharpened in this class.
- This course, I think, I very similar to the industry in regards to tools and projects
- Few choices during the summer.
- The subject matter was interesting and useful. I haven't done much object oriented programming before and I knew it was an important subject to spend more time on.
- Rather than just listening to the concepts, having a chance to experiment made me stay in the course.
- A great instructor and my desire to graduate.
- Course was clearly high-quality. Requirements were well-defined. I enjoy Java and needed more masters credits.
- The projects were relatively fun.
- The interelation of growth in concepts one by one helped to have the class.
- The course content and projects
- I program in C during the day time. Programming java via IDE was a nice change of pace and exposed me to different programming practices.
- The process of becoming familiar with a lanuage over the course of projects is enjoyable and a great way to learn.
- I wanted to learn how to implement REST and Rich Internet applications. Alos, I was interested in design patterns in programming.
- All the stuff we learned in this class.
- Solid project which reallt help me learn a lot
- Its required! Also, there are very few actual programming courses offered as PSU. So much of the requirements and electives are theory/math only - that I often feel like I'm not going to be prepared to go into the field of programming because I haven't spent nearly enough time learning to do it.
- The fact that this is a programming class to learn about Java programming language. Almost all other CS courses tend to be theory and lecture based and the number of classes focused on learning new programming languages are very low, especially for graduates.
- I needed a programming intensive elective to take Capstone in the fall
- I always thoughts that Java is something I need to learn and before this the only language I knew was C++. Java is one of the most recognized industry languages and for making myself more industry ready it was a must for me to take this course and educate myself. Although I tried to do the first assignment and partially failed, my will to complete this course became even stronger and I pushed myself to get things done.
- Required for graduation/continuing capstone.
- I enjoyed almost everything in this class, the lectures, were very comprehensive, interesting. The projects were very challenging which is best part becuase I learned a lot of intricate concepts in java as well as oop working on projects. The koans were really cool, interesting and helped to build testing skills.
- The content was interesting, and you're lectures are interesting enough to keep attention. A lot of the other CS professors that I've had simply read off of a powerpoint, which isn't especially helpful for actually learning content. I think the more hands on programming/design discussions were also useful.
- I need the credits and I don't like to quit.
- I wanted to learn Java and I paid for the course out of pocket.
- The professor's teaching and the amazing projects.
- I like organized courses/teachers. Dave is really structured and prepared, which I appreciate.
- Good organization. Clearly defined project guidelines. Good instructor communication.
- The material wasn't too hard and was extremely interesting.
- I felt that learning Java and object oriented programming in general are of great practical benefit to me moving forward. I really enjoyed doing the projects: I felt like it was a great way to get a feel for Java's utility.
- Professor David made the class so much fun and interesting. I enjoyed coding in Java.
- My desire to learn java.
- I wanted to improve my knowledge of Java. Prof. Tolmach mentioned that by some estimates it is the most widely used programming langage in the world. I wanted to be able to develop with it well.
- If you had to remove one lecture from this course, which would itbe? Why?
- I can't think of any that weren't useful.
- If I need to remove one, I will choose injection. This topic does not seem to have much relevance to the assignment. And it does not appear in the scope of final. Several other lectures are very helpful to the project. When I don't understand the project requirements, I will go to see these lectures to find ideas.
- Because we only had 7 weeks of lecture, I feel like all of them are valuable, because they all are teaching you how to work on the project and coding in class.
- Probably the web stuff. As I mentioned PSU does not prepare its students enough I feel for the real world. In my other classes, when I've been on group assignments, nobody knows how to use GIT. They dont know how to write unit tests or integration tests. I'm glad you do at least touch on some of it, but I feel like that is more beneficial to students than web development.
- The functional one, purely for personal reasons, I don't like functional programming.
- Nothing to be honest because all was needed at the end.
- The lecture where you live coded the majority of project 4. I did not pay much attention as I knew I could just follow along later, and it didn't motivate me much to actually learn how to implement REST. This is apparent in my lower grade for P4 in comparison to the rest (eyeroll)
- One of the lectures where we did code katas. I didn't feel it was useful to practice pair programming during lecture hours. I would have preferred a deeper lecture on reflection.
- Probably the design pattern part because it was too short? But I believe it would be more helpful if you can talk more about it.
- Can't afford to get rid of any of the lectures as it was already too short of a term especially having lost an entire week to the fourth of July.
- I'm not sure which lecture I would like to see removed but one lecture topic that I wouldn't have minded seeing more of was on using different development technologies such as Intellij, github, etc. I know we were exposed to them several times during the class but a little more focused discussion on them might have been helpful.
- I'm not sure. Sometimes the coding examples where too fast and long to keep up with. However, after class I would watch the videos while doing the projects and they were very helpful. I would suggest to have more class feedback while coding so that we have to stay more engaged while you are coding up front.
- I would remove the tennis kata lecture because I feel like I already have a string background in OOP and pair programming. I feel like I didn't learn much.
- IMO the GWT lectures can be shortened, or taken from the perspective of what kinds of ecisions were made for what reasons. I'm pretty sure knowing a lot about the internals of GWT isn't as important as knowing (or guessing) why the engineers made certain decisions.
- GWT is considered by many (most?) to be very outdated. But, it is a Java class and I get why you want us to make a full-featured web app rather than just another command line program. It's still a good exercise even if we never use GWT again. Maybe there's a better alternative though.... I don't know.
- I did not show up to class physically very often, I just watched the screencasts online the day after. With the power of running videos at 1.25x speed and skipping around to parts that were more helpful to me I don't have a good answer for a lecture I would get rid of.
- Not sure I have a good answer for this one so I am not going to make one up. I can tell you what my most favorite was though, I liked the little bit we did on design patterns because I find them to be interesting.
- I wouldn't remove anything. The course had limited time, and I think everything we covered was valuable.
- The week 5 or 6 lecture where it was really hot.
- Hard to say...they all seemed pretty valuable but I focused my attention on the ones directly connected to projects.
- Honestly, I can't think of any lecture that wasn't useful. I found them all equally relevant and applicable to the course.
- I would merge "Core language APIs" and "Core Java APIs" into a single lecture. These topics had been covered already in the intro to Java during lower division classes and don't need as much focus (just a brief review).
- Most of the "watch David code" lectures were not all that helpful.
- For myself, It's really difficult for me to have the lecture be useful when it's talking deeply about a project that I have not started yet. I've finished all the projects early, but because of the overlap it's hard to have started by the time lecture rolls around. So that's not all that useful for me, I nearly always have to get started, and then go back and watch the screen cast.
- I didn't feel any of them to remove.
- I 'm not sure since each topic is very helpful
- I would refrain from the lecture where you went over most of project 4. I think I would have learned the material a little better if I had the opportunity to struggle with it.
- I would un flip the class, at least for summer term, and lecture on the java material rather than going over the projects. I felt that during each session I was one class behind the material being presented on a project, despite being turning in projects on time. I understand the attraction to a flipped class where material is read before and discussed in class, however I personally enjoy material lectures.
- I would remove the implementing koans lectures. I think they should be done individually.
- Design Patterns. Have learned OOP design from CS202.
- Maybe the koan one, we can just figure it out ourselves.
- N/A
- I would remove the GWT lectures and instead build upon Project 4 to include more modern Internet application tools and methodology. I think it would help immensely for students to know how Java can be incorporated with modern web application technologies. Another idea is to scrap GWT and do a small Android application development lecture and project. Perhaps a simple Android app project to gain exposure on how Android app development works.
- The one where we spent half the class talking about what people did on the Tennis Kata instead of spending more time on the actual development process
- I cannot name any because I learnt new topics in every lecture. Removing any one would be a loss for me. Infact I won't be able to suggest any topic which would have been a better aletrnative. Only one issue I faced is coping up with your pace of delivering a lecture that made me revisit screencast often to understand things and that might very well be lack of speed in understanding things.
- I thought they all fit in well with the course structure.
- I don't think I would remove any of the lectures, they are all really great and very helpful for working on the projects.
- I'm not sure if theres a specific lecture I would remove, but I think some of the walkthroughs of the projects were a bit longer than was necessary. The setup steps were definitely useful, especially for looking back on in the videos, but the just coding itself, at least for me, was not as useful.
- Pair programming. I prefer to work alone.
- I don't think any one lecture should be removed. I feel that each one provided some knowledge into Java programing conepts.
- I know I learned a lot from gwt but instead of gwt learning different frameworks like spring would have been good too.
- n/a
- GWT as it is not used in the real world.
- The GWT material. GWT isn't really relevant to web development anymore. It also uses Java but it doesn't need advanced Java topics to be able to use.
- None come to mind.
- It would be great to have a project and lecture on how Java works with web technologies. The lecture/Project on GWT can the replaced with a creating a website for the Phonebill application. It would have been easier and interesting to create UI with HTML , CSS , Bootstrap etc for the phone bill application.
- Can't say that there would be any lectures I would remove. It would be nice to add android development, but I don't think you can squeeze that that into an 8 week course.
- If necessary, I think the content of the core language API lectures could be combined into one lecture. And then the lecture notes could go into more detail and be easily referenced.