Course Details

Pros: 1. Encourage use of LLMs for the HWs (explicitly not the shared assignments FCs) 2. Good, entertaining lecture 3. Engaging assignments Cons: 1. Keep up with the due dates 2. Android studio updates 3. Detailed Review: Honestly, I really like this course. I'm not an SWE, so this was my first software-design course. It wasn't too demanding. The final project is what you make of it. I was fortunate enough to be able to tie the project to my job, so two birds with one stone. Strong suggestion: get an android phone. Running your apps on your phone is so much better than emulating. You will learn to get deeper into edge case tests. For the HWs and partner-assignments (FCs) you have access to a fixed number of "slip days" to allow for life events, but be too spendthrift with them. Assignments get harder over time. They were not allowed to be used on the final project.

Pros: 1. Professor/Recorded Lectures are great -> funny and helpful. 2. Assignments scale and build off each other well. 3. Very practical, and offers skills that are good for basic software engineering practices. Cons: 1. Professor is not active in the course anymore (at least this semester) it's only run via the TAs. 2. A lot of assignments, you can find yourself backlogged if you're not careful. 3. Detailed Review: This course is probably the most fun I've taken in the entire program, mostly due to the professor and the assignment quality. It's pure practical/programming with no theory involved so be prepared for that. The Assignments build off each other well and introduce new android programming features slowly but surely, allowing you to grasp one feature before moving on to another. The final project is also quite fun and allows for a good amount of freedom to develop whatever app you want to. I went from not knowing anything at all about android programming to building a fairly close to accurate full-stack app in the span of one semester, so you definitely learn a lot in a short amount of time. With all that said, be prepared for a lot of assignments. Work is mostly split between FCs (short assignments that are designed to make you work with a topic introduced in a lecture that week) and HWs (longer assignments that are combinations of topics and are more focused on actually using features in a real life app idea). These come pretty rapidly and if you're not careful you can find yourself in a situation where you have to juggle 2-3 assignments at a time (especially close to the end of the semester when the project is due). Also, be prepared for a course with no interaction with the professor. From past reviews I'd read that the professor used to be quite active in the course but that longer seems to be the case. Unfortunately that seems to be the norm for this program now.

Pros: 1. Lots of implementation 2. Fun project at the end Cons: 1. Homework heavy 2. Code heavy Detailed Review: If you are a code machine this is the class for you. Everything in this class is just straight implementation in kotlin. There is no exams but the homeworks do take some time to do so I would start on it early. There is also a final project at the end where you will have to create a video as a demonstration.

Pros: 1. Limited workload allowed managing busy life and work 2. TAs and Prof were responsive 3. Final project was team based Cons: 1. FCs are due each week 2. Video lectures are useless outside of FCs/HWs 3. A particular FC required us to share our Google API key in plaintext Detailed Review: I liked this course and after being 5 years in this field I can say this is the closest you will be to an SDE experience at MSCSO. You can take this course to gauge if you will like it or not. The course itself was easy and manageable, and the frequent deadlines were easy to manage especially if you work with somebody else. Prof Emmett is the coolest Prof in this program and has a personality, and frequently answers questions on ed discussions, which is something I have not seen any other prof do. My only gripe is that this course felt a bit too underwhelming to be a part of the master program (on campus version is offered to undergrads).

Pros: 1. You'll get to write a fair amount of code, including for a project you choose, and Kotlin is an enjoyable language to learn and use. 2. You don't really need to watch any of the lectures if you don't want to. Reading the Android documentation and referencing the sample code provided is enough to get you started on all of the assignments. 3. There aren't any exams to worry about. 4. The professor was incredibly engaged compared to any other online class I've ever taken. Cons: 1. If you do want to watch lectures, they aren't organized well on edX. 2. XML layouts are somewhat outdated and tedious to work with. 3. Skeleton code is provided for every assignment except your own project. This is both a pro and a con, you'll get done with the homeworks faster but you also won't learn basic techniques to deal with dependencies or how to structure your projects early on. Detailed Review: I meticulously tracked every minute I spent on this class. Over the course of ~14 weeks (since this class' last assignment was due approximatively 1.5 weeks before the end of the semester) I spent 139 hours. So overall, just under 10 hours per week. I think this is probably a good first course to start with in the program since the workload is manageable and you do learn some concrete Android dev skills. That being said, this might stand alone in this program as a course that is exclusively applied and introduces no theory or concepts. Lastly, I do want to mention that the professor and course staff were very helpful and responsive on ed. This doesn't seem to be the norm for other courses so it was refreshing to see.

Pros: 1. Professor involved 2. Instructions were straightforward 3. Cons: 1. Some videos are outdated 2. 3. Detailed Review: For me, this is the best course that I have taken in this program. The videos were quite helpful and the expectation was clear on the pdf instruction. There were lots of hints on the codebase and the Instructor posted some new videos to update older ones. Although, I spent lots of hours on the HomeWorks but it was worth it since I had to do a lot of debugging.

Pros: 1. Easy to understand material. 2. Professor provides relevant demo code for assignments. 3. Cons: 1. No viable lectures on EdX or Canvas. 2. Android documentation is still lacking :) 3. Start of the semester was rocky with little to no communication from the instructor/TAs. Detailed Review: Android Programming still has 5 (really, 4) "homeworks" that are essentially projects. These are the most time-consuming parts of the course. These are not entirely difficult, but do usually require you reading up on some Android documentation to complete. Overall, not entirely too difficult. It also has 10 flipped classrooms that take about 1-3 hours, depending on the quality of some of the demo code provided. The demo code usually lines up pretty nicely with the flipped classrooms, so you're almost always given a working example of what you're expected to do. Finally, there is one final project, which is essentially an app that you build from scratch. You get about 1 month at the end of the class to work on this with no other assignments other than the report that goes alongside the app. You are not asked to reinvent the wheel here, and are really just expected to showcase what you learned throughout the course. Still, you are not limited here, and there were some really cool apps made. Overall, this course is a fun, light course to pair with another class if you've programmed before. Even if you haven't, it is still highly doable as you end up needing to reference demo code and Android documentation frequently. The only gripe I have here is the lack of interest in providing a clear lecture set, as most of the existing ones in EdX are outdated, or extremely out of order. It did not seem like anyone wanted to take care of that, with the professor just saying he would not do anything on the EdX side. The code you are provided, though, is enough, but it sure would be nice to have some actual lectures to watch.

Pros: 1. Prof has a personality 2. More practical and fun than other courses in the program 3. Open ended final Cons: 1. Course material is outdated 2. Lots of work 3. Android documentation is bad Detailed Review: I really wanted to like this course but find myself feeling somewhat disappointed. I liked that the course was closer to something you'd do on the job as a software engineer, rather than heavy theory and navel-gazing. The professor also injects some personality into the lectures, which is certainly welcome considering all the other courses (this was my 9th) are pretty dry. The assignments are pretty straightforward (though with very lengthy prompts) and are clear about all the requirements. The final is basically just build an app with a certain degree of complexity - it should be about 2 homeworks worth of work and should use a couple external APIs/libraries. This was pretty fun and let people be creative. There were several things I didn't like. The course material is very disorganized - at the start of the class it was super confusing because the videos are hosted on a mix of EdX and the course website and on EdX were out of order. So I spent the first week or two watching lectures with no sequential logic or context, until the TAs explained that we should just use the course website. There was also a grading SNAFU on the first assignment - a ton of folks got bad grades because of some automated tests they ran against the repository, and the tests were clearly broken. This led to a ton of back and forth with TAs and the professor, and the grades were subsequently adjusted. But it was pretty stressful (that said I didn't miss a single point for the rest of the assignments that have been graded to this point). Most importantly, the course material is old and needs to be updated. Android is moving from XML views to Jetpack Compose, and many of the course videos are several years old and are or will be obsolete very shortly. I'd recommend waiting to take this class until it's been updated, unless you just need a credit to graduate. Last thing, I thought this class was a lot of work. I think I spent ~15 hours a week or so, and I expected to spend maybe half of that, considering I'm a SWE with ~8 years of experience. None of it was particularly difficult and I never found myself in a time crunch, but it was just a high volume of assignments and you really have to put the time in to make sure you're meeting all the requirements and catching all the edge cases. Some people say you can breeze through the flipped classrooms in half an hour - I did not find that to be the case. I'd say they usually took me 2-4 hours. Maybe I just suck, who knows. It also doesn't help that the Android documentation is really really bad.

Pros: 1. Projects are straightforward, well defined, and not particularly challenging (if you have worked as an SWE) 2. Course material is very relevant to mobile application development 3. Excellent Piazza support Cons: 1. Lectures aren't structured to follow the course progression, they're only really useful as a spot check for particular features you're working on at any given time. 2. If you don't have much practice self-debugging and revising software you've written, you're in for a rough time 3. High volume of assignments. 9 Flipped classrooms, 5 homeworks, and a final project Detailed Review: I really enjoyed this course. The assignments build off of each other well, the homework is not too difficult, and there are no "Gotcha" assignments. Everything is straight forward and well defined. You are told exactly what the assignments need to do, what functionality the app should have, and potential edge cases you may need to consider. Plus there is the bonus of the final project being fairly open-ended, so you are able to tackle any android application that you are passionate about building within a set of pretty loose requirements. The assignments are also all laid out in the MVVM framework which is helpful for learning about the structures of on-device applications. As others have said, out of all the classes in the program, this is probably the closest you will get to software engineering as a job rather than computer science as a field of study. The assignments are not focused around learning theory laden concepts and are instead focused around continuously writing close to production level code. Similar to an entry-level software engineering role, instead of building a small assignment from scratch (with the exception of the final project) most of the homeworks and flipped classrooms are "go build this module" or "implement and integrate this UI component" of a larger project. For those who have worked as a full stack or mobile software developer, this course may seem trivial at times. For example, some of the flipped classrooms took me ~30-45 minutes. Even if you have 0 professional development experience, the course is still very doable, just might be a bit of a learning curve to the change in structure. You'll quickly figure out whether you like the difference or not. The caveat to all of this is this course basically assumes that you can effectively read, write, and debug code. I reviewed my git history for this review and my commits for the course totaled ~8000 lines of code across all the projects. The course also covers numerous different external APIs, outside libraries and resources, and concepts like asynchronous programming, atomic data, events, lifecycles, REST APIs, databases, authentication etc. Interfacing with all these components is fairly standard, but you're given the links to the read the docs and resources and expected to run them down. Some people really don't like this style and prefer the content to be in the lectures, but I felt that it is more of a preference thing than a good vs bad. The last thing about this course that was great this semester was the course staff and Professor Witchel are very helpful. The TAs and professor would respond to discussion posts all the time and there was generally very good communication. Also, Professor Witchel's teaching style is just fun. It's never dry, always very relaxed and easy going.

Pros: 1. Practical material 2. Fun assignments 3. Final project really pulls together everything you learn throughout the course Cons: 1. Disorganized lecture materials 2. Constantly changing assignment due dates 3. Detailed Review: Breakdown of time: (HH:MM) Final Project 28:48 Final Project Proposal 2:08 Final Project Reviews 0:45 Flipped Classroom 0 2:14 Flipped Classroom 1 2:14 Flipped Classroom 2 1:29 Flipped Classroom 3 2:04 Flipped Classroom 4 1:23 Flipped Classroom 5 5:54 Flipped Classroom 6 2:03 Flipped Classroom 7 2:15 Flipped Classroom 8 4:32 Flipped Classroom 9 2:33 Homework 0: Setup 0:51 Homework 1: Peck 7:37 Homework 2: Fling 4:50 Homework 3: Mplayer 8:28 Homework 4: Reddit 14:18 Lectures 11:17 Total 105:52 Note: I paired this course along with SIMPL. The course got off to a bit of a rocky start - all of the EdX lectures were super disorganized (had dates from 2022 and a bunch of outdated content) and there was a terrible lack of communication at the beginning of the semester. Thankfully, the communication improved throughout the semester. The organization of materials did not - EdX was a mess from day 1 until the end, probably because they didn't want to invest the time in reorganizing because of the shift to EdX. Logistics aside though, this course was really fun. The structure of the course is great - basically you have a set of lectures and some external reading material that pairs with a flipped classroom to help you get hands-on experience with the topic. The homeworks then dive a little deeper into the lecture materials and have a slightly larger scope of work. All of the flipped classrooms and homeworks feel like you're bowling with the bumpers on - a lot of the code is provided for you and you just need to fill in the blanks. When you get to the final project, however, you're on your own. You'll need to stand the project up from start to finish. This was, in my opinion, the most rewarding part of the class because everything you learned throughout the yeas comes together here. Overall solid course, would recommend - especially to those newer to the program looking for an easy first course.

Pros: 1. Gives a lot of Android knowledge and make you good at it 2. Professor is very understanding 3. TAs are helpful and generous Cons: 1. Some assignments materials are not covered in lectures Detailed Review: Emmett is the coolest professor I've ever seen. What makes him different than other professor is that he is very active on Piazza. He blends in very well with his student despite the age gap. He explained the lecture and assignment very clearly. The TAs are helpful and generous. You will learn a lot in this class, especially if you're not an Android developer.

Pros: 1. Lots and lots of practical code written, Kotlin is an amazing language that's worth learning 2. Funny, interesting lectures and novel flipped classrooms 3. Responsive and helpful TAs and classmates Cons: 1. The Android SDK (Software Development Kit) is pretty garbage and keeps changing 2. Since there's so much code/so many assignments, there's pretty frequent bugs 3. Some of the projects and FCs are much harder than others Detailed Review: I really enjoyed this class and would recommend it to anyone who wants to be a really good Software Engineer. It'll give you practice working with some cool, bite-sized problems through the Flipped Classrooms; it then expands out to larger efforts via the projects. You'll work with some really bad spaghetti code but also get to refactor and improve it to make it make sense. You're working with a constantly changing framework (Android SDK) that has a LOT of critiques but is slowly getting better. Most importantly, it's truly just a lot of code that you get to write; lots of practice. Well worth it, if you're a strong engineer! No other class gives you this much volume and reps.

Pros: 1. Good breadth of information related to Android programming 2. The projects ramp up in difficulty in a nice way, while later projects can be a bit time consuming the actual difficulty of them never gets too bad 3. If you already have a good amount of CS or SWE experience, the concepts found in this class aren't too difficult to grasp your mind around 4. Professor's pretty cool, his lectures were fun to watch, he explains a lot while keeping it lighthearted Cons: 1. As mentioned earlier, while the actual DIFFICULTY of the concepts isn't bad, the time commitment for the course is pretty substantial. I have nearly 3.5 years of SWE experience so many of the things we implement weren't difficult to do necessarily, but navigating around Android Studio, Kotlin, understanding the project requirements, then actually coding it out took a good chunk of time for me near the end of the semester Detailed Review: Overall, if you have prior SWE experience coming into this class, you can expect it to be easier than most other classes you've probably taken. Keep in mind, however, the time commitment is not as low as you may have expected. There's a good amount of time to be put into the class, though the actual material itself is not challenging per se.

Pros: 1. Good progression of difficulty throughout semester. 2. Assignments are well thought out and focus learning 3. Cons: 1. Android APIs can be frustrating to learn. 2. Takes time to get comfortable with the material. 3. Detailed Review: Overall I really liked this course. It is more practical training for a software engineer than any other class I've taken in the program. The assignments were well thought out, and give you enough to start so that you can focus on learning the concepts at hand. Complexity is added as weeks go by and some of the training wheels are taken away. The time investment will vary greatly depending on your experience. If you are not comfortable with app development it could easily consume 20hrs some weeks. Of the 8 classes I've taken so far, this is probably my 2nd or 3rd favorite.

Pros: 1. I learned a lot in this class 2. The grading is lenient 3. Project-based, no exams Cons: 1. A lot of lectures are outdated, so you have to learn by your own. 2. I would say the TAs/Instructors aren't helpful on piazza. Most piazza questions are answered by other students. 3. The intervals between assignments are very short. 4. Assignments are some times confusing cause there are a lot of ambiguity. 5. Unorganized class structure. Detailed Review: TLDR: Pretty easy class to get an A if you put in the work to learn on your own. Unhelpful TAs/Instructors. I came from very little CS experience so the assignments were pretty tough and time consuming for me. Since most lectures are outdated, I had to pretty much google and learn from YouTube tutorial for most of the assignments. The flipped classrooms or mini homework would take me on average 5-8 hours and the homework would take me on average 20-30 hours. Lecture Quality: The first thing that made me disappointed in this class. A lot of the lectures materials are outdated making me hard to code along the lecture. The lecture was made on 2020 and android has made a lot of changes to their API/elements. Only 1 new lecture throughout the semester. Professor Quality: Typical university professor, the professor is great at the subject but not great at explaining/teaching. I wish the professor could be more straight to the point when explaining concept/assignment. Piazza Support/TAs: Not that helpful, most of the time their answer to piazza question is just to refer to android documentation. A lot of unanswered student's questions. Class Difficulty: Overall very double to get an A even if you're new to programming just takes a lot of time. Grading is very lenient, in most assignments students get above 90%. Stats of the assignments: HW1 (out of 30): Mean: 26.14, Median: 29 HW2 (out of 33): Mean: 31.99, Median: 33 HW3 (out of 58): Mean: 56.24, Median: 58 HW4 (out of 47): Mean: 43.64 ,Median: 47 Final Project (out of 100): Mean: 92.15, Median: 95 Flipped Classrooms assignments: Pretty much most students got 99% for all of the assignments.

Pros: 1. Easy and the requirements are clear - if you know programming you'll do well in this class. 2. 3. Cons: 1. 2. 3. Detailed Review:

Pros: 1. Homework and flipped classroom assignments are not difficult to finish. 2. Quite lenient grading system 3. Tutors and professor are active on Piazza Cons: 1. Basically, all the assignments are "fill-in-the-holes" type, instead of learning how to implement things from scratch. 2. Very confusing instructions 3. The intervals between assignments are very short. You really have to make sure that you carve out some time every week or plan ahead. Detailed Review: It is not an "academic" course. You don't have to follow the lectures to be able to complete the assignments. It is a quite easy course as long as you plan everything ahead.

Pros: 1. Lots of extra Android support available through documentation and StackOverflow. If you know how to Google, you can find pretty much everything you need 2. Shouldn't be too hard if you have development experience (there's lots of starter code given, a lot of the class is just filling in the right Kotlin code) 3. Kotlin easy to learn, particularly if you know a JVM language already (previously had Java and Scala experience) Cons: 1. I never want to touch Java code again after learning Kotlin Detailed Review:

Pros: 1. Demo code provided is well-commented and compliments lectures nicely 2. Project-based, no exams Cons: 1. Socratic piazza format with lots of over-ambitious students providing incorrect answers 2. Lectures are not very helpful if you are already an experienced programmer demo code is sufficient Detailed Review: Project-based course that anyone who his written and delivered production-level application code will find fairly easy. Weekly "flipped classrooms" that take ~1-3 hours to complete and bi-weekly homework assignments that take varying amounts of time (each homework gets progressively more involved) but for anyone with the programming experience I mentioned above, should take no longer than ~15 hours. Without solid programming experience, I would HIGHLY recommend taking some MOOCs to prepare, as you will find this course work-intensive. My biggest gripe with this course was Piazza, though the issue may be only specific to this semester. There were plenty of threads that would be answered by students only, with incorrect or incomplete responses, that the instructors would not answer (presumably because Piazza marked the question as "student-answered"). Programming tends to fester egos, so I think this was just the result of several experienced programmers thinking they could answer every Piazza thread by themselves. Questions regrading some unclear corner cases in homework assignments would often take awhile to answer because of this, significantly delaying development/completion efforts.

This course is purely about programming exercises. If you've shipped code before, this won't be particularly challenging. If you're relatively new to programming, it'll be a fair amount of work. There's helpful code in the class exercises, but a fair amount of figuring it out on your own. Some of the lectures are outdated so are no longer relevant, and the teacher/TAs help on Piazza using the Socratic method which isn't particularly helpful. Watch the videos and use the demo code to get you through the homework exercises.

Pros: 1. Programming heavy and very application focus 2. Lectures are fun and often times not boring 3. TAs are very helpful on Piazza Cons: 1. VERY heavy workload if you have not done Java and Android development 2. Weekly homework and assignments, making it very very rushing 3. Hard to complete the assignments if you do not have enough time to understand the concepts Detailed Review: I strongly advise to only take this one course for the semester if you have not done Java or Android before. Every week there will be one or two deadlines to complete.

If you've shipped applications to production before, then this course is very easy and is just like writing code for projects at work. If you've never worked professionally as a software developer before, then this course will be tough because you are not given much support in learning how to program, and you're expected to figure everything out for yourself, know how to do debugging, etc., the instructors' answer to most questions is "figure it out" (which is usually what your boss will say to you too). I never really watched the lectures, I just implemented the projects directly from the spec, which is like what you do at work.

Good course. However, if you haven't learned about Java, it would be stressful.

Really good course; though, I figure that this is probably strongly due to my experience in software engineering. If you're coming from little or no programming experience, this is going to be a challenging course. The course is basically straight up app programming. The lectures are great, but the order of the lectures is a little wonky. That is, sometimes you'll hit a lecture topic that would have been really useful a week or two before, and sometimes you'll hit a lecture that you wont have enough background to understand until a few weeks later. MAJOR CON: There were 3 TA's and they were STILL really far behind in the grading. Something like 30% of the course grades were not realeased until AFTER the final project was submitted. YMMV on this probably depeding on the semester and the TAs. I got the sense that the instructors were a bit "checked out" for active engagement, but they did ALWAYS respond to comments eventually. Despite these negatives, the course was still 4.5.

This class has the most programming of any master's class currently offered by UT Austin (according to the professor). It is a TON of work. Be prepared to have time in your schedule to work on this class. As time goes on, the assignments get harder and require even more time to complete--be ready for that. Give yourself an entire weekend plus a few hours during the week for HW1 and HW2. HW3 will be a little more. HW4 is a beast--give yourself two entire weekends to do it. The FC's also vary in difficulty--the easy ones take less than 4 hours but the hard ones can take up to 8 hours.

I bought the textbooks that were recommended in the syllabus -- both Big Nerd Ranch books for Android and for Kotlin. These helped tremendously in the beginning getting ramped up. I used them through the first two homeworks and then felt good enough with the videos to get through the rest of the class. You get enough starter code for the homeworks and flipped classrooms to make sense. Just plan ahead for homework 4. Class wasn't too difficult and overall will teach you the basis of making an app. Spent alot of time on Google and Stack Overflow. Would not count on the TAs for help -- office hours are usually full and you might be in a waiting room for the full hour and not get to ask your question. Not sure if thats the norm with these big classes but it was frustrating at first.

I would start by saying that your background matters in terms of the pace of this course, especially in the beginning.I had never done any app style programming, so I found it took awhile to get used to the idea of having to coordinate layout with the actual logic. Android programming in Kotlin ends up being just a long procession of API calls, which is both a blessing and a curse. The text for the course is Kotlin and Android docs, which I found to sometimes be as obtuse as you can imagine, with relatively few examples and sparse explanation. You will google things....constantly. His demo code is good for "what" to do, but he didn't explain well why or how it was actually doing what he wanted. I would liken this course to more of an informal tutorial than what you would expect from a graduate course. As far as the professor, he's rude, condescending, elitist, and far too worried about being snarky and cool for my taste... personality differences aside, you will learn how to program apps in this class....sink or swim is the mantra.

This class gives back what you put into it. If you just want to pass and get an A you can do that without too much effort. However, if you want to really dive deep into Android Programming, this class gives you the tools to start doing that and get familiar with the Android environment. Personally I did not watch the lectures after the first few weeks as I didn't feel the videos were very useful, so I just did the assignments with a lot of Googling and finding specific relevant parts of the lectures that I needed. The assignments themselves are mostly fill-in-the-blank stuff, where the prof and TAs set up the hard stuff for you in starter code and you just have to finish it off by figuring out what's left to make the apps work. The final project is a full app from scratch, and it's pretty fun. People made some very cool stuff and put a lot of effort in. Overall, this was a pretty fun class and a good intro to Kotlin/Android. Also note that he says you should know Java or Kotlin when you come in, but I didn't know either and still kept up fine, you will learn along the way.

I know some students like Professor Witchel's teaching style but I am not a fan of sarcasm. I felt that the course videos could be better. Some videos were okay but I felt that the in-class videos were especially bad and that the order and flow was not great on edX. The material is not too difficult but can take time depending on programming background. Some assignments are long because it took time to learn the material but I think it was manageable. Piazza was more helpful with hints and assistance from other students. Assignments are usually posted on Monday/Tuesday and due Saturday or Sunday. It would be nice if we got them on the weekend instead since many students work during the week. I think the time to grade the assignments was too slow. It's the end of the semester and we still have 2 homeworks that have not been graded. The homework and flip classrooms come with starter code which was not good for the final project because we did not learn some topics like setting up projects, activities and gradle. I am not sure what makes this a graduate level course. It seems the same as the undergraduate version. The weighting of the final project is low so you can not work too hard on it and still make an A as long as you did well on the assignments.

The course is a basic introduction to android app development, no more no less. The professor's lectures are interesting, but it isn't entirely needed to watch them. The project is broken down into weekly assignments which generally take a few hours to do, and 4 longer projects which usually can be knocked out in a day or two, except for maybe the last one. The administration of the course was a bit fustrating at times, with it taking months to get feedback for grades, but overall a decent course, if you want to learn the basics of android programming.

This course is a good one. It seems a little bit random at times, but the professor knows exactly what he’s doing. If you work just a little every week, you’ll have a decent android app development level by the end. As for the workload, be careful: This was my most time-consuming course for the first month. Then, once my mind started to wrap around this android stuff, I did the work relatively quickly. Tip: DON’T neglect the layout part (XML files). Especially “constrained” layouts! The professor trains you on them at the beginning, then hardly ever mentions them again. BUT, you’ll need layouts throughout the course.

Thoroughly enjoyed this class. Time consuming in the beginning as you are getting used to kotlin and how to make android apps. First few assignments were time consuming for me because of this. No exams, only programming projects and weekly homework’s. Final project is open ended and you learn a lot from it. Highly recommend this course.

Good to have a UI class in the curriculum. Teacher is very entertaining. There are short assingments due every week (3hrs each) and longer homework assignments that can sometime be very time consuming while still having a short assignment due at the same time. Plan accordingly. Content was manageable. The teacher expects you to go out of your way to find how to do things, which makes sense for a graduate level course. I found Kotlin to be frustrating as there are things your can do in certain areas of code that you can't do in others, and its not very clear on which. Overall, good course, diverse content, but cohesive and incremental nonetheless.