droidcon SF 2018 - From Effective Java to Effective Kotlin

I had this nice coat and I was like yeah this should bring the same integer right but it actually didn't bring the same integer this is a Java code and it's because it's a classic issue in Java where we are checking for referential equality instead of a value equality so if we want to do it right we need to use the actual equals method in the object and then it works these are really ridiculous example but there are many many small things like these in the java language and after hitting them all at once because that's what happened I got a little bit uh officiated by Java that's a long time ago but thankfully I had a really good mentor and he bring the table back to me and he told me why don't you check this book effective Java how many of you have read effective Java here nice wonderful what a memory so many memories so the good thing about effective Java is not only allows you to walk to work around some of the Java deficiencies or issues it actually gives the reasons why those things work well to make good code and good api's and it was one of the first books that gave me a critical thinking necessary to build good software so you know this is one of my favorite books all time anyway let's talk about the journey from the core from the coaly in a from the java world to the coding world and let's see how actually 15 years of experience give you something on the calling wall hopefully and how effective Java actually translate to effective : let's get some fireworks so my name is Roberta Camacho and I like it's light animations as you can see I'm an Android developer and Mary Carey I've been doing Andriy for quite a while now you can follow me into here that's my handle if you want no worries no hard feelings and so you have to imagine that how many of you actually work in a code base that it's a hundred percent called in lucky you guys congratulations enjoy life don't don't worry about this yeah so for the rest of us the problem is we've been working in Java we were working in Java for a long time and we actually create a lot of tooling to avoid the classic issues in the java language so for now it's a little bit difficult for us to migrate all of these things because we already have all these libraries static analysis that help us to use Java without thinking too much in some of the issues so we need to come you know we need to live with Java too for some time and we don't have a strong right now a strong reason to actually be super strict about using coding because you know let's just think about it : beta one was in 2015 so it's not a long time ago Java has been there forever like literally I was a kid yeah that's Java and then so in 2017 was when Google actually announced that he was support that the company was supporting calling as a first party language so anyway this was my friend for long time when I was in college I went to the bytecode and then in the same place you can D compile and see how it translated to Java so I was able to leverage till the Java knowledge and help me to get into : so I recommend you to actually do command shift 8 and search for this and have it there always when you have some issues or either know exactly what Colleen is doing under under the hood so this is your friend forever ok let's get into effective Java how do the items in the book translate to actual : there are actually many of them that are obsolete now which is good we don't need to remember more things we can actually focus on delivering features I'm gonna just check the ones that I'm more excited about and that makes my life and hopefully your life is here so for example the item number 3 is enforce the single property with a proverb ah this is pretty much this is how you should implement Singleton's the thing is a single torsades so common that why do we even need to implement them every time and why do we actually need to invest time on thinking how do we implement it properly so this is the effective Java solution just use a enum because enum gives you its serializable and thread-safe so that's good because some issues not lazy loaded so it runs in memory right away but recording creators we're smart enough to say let's just create a keyword called object and that's a singleton implementation so developers don't need to actually have discussions on how to implement over and over singleton and then if you go to the decompile java that colin generates which is the one in the bottom it's actually a lazy load Latian loaded scene upon implementation where it is a static block in that static block it's only gonna be loaded one time whenever you need that singleton so this is great we don't have to think about this anymore forget about this item to consider a builder when faced with many constructor parameters I love the items they are so poetic so that is the imagine this is a common scenario in Java we have this spazio class where we want to store data from from network or from the screen so imagine we have this item and that is ID name on description and then you want to do it nice you want to use a builder because the builder you know you can put names on the method and that's great because it's more readable it's more maintainable and it allows you to check each time if they are required not required things like that but you have to be you have to do this all the time many many times and for many different many different classes in the in the codebase so it's a little of lines but imagine if you multiply for many of them why just not using like what Colleen did which is like you have required parameters and optional parameters and then that's it and you can use JVM overloads you generate for Java one to n constructors and then you can do something like this or you can actually use named arguments so this is actually the same idea as a builder like you're naming the parameter you want to set because the problem here is if you have all the fields with similar types you're gonna end up swapping them because we are humans and we mainly stakes especially am I really I make a lot of mistakes so that's why the Builder was really useful for me but with this I don't need to write the Builder myself and I can use name arguments or just default parameters so this is again some code that Colleen does for you so now every parent anymore so let's talk about the item for you I consistently use the override annotation this is a really fun nobody we don't do this we just forget because listen our goal in life is to compile code we don't care about the code that is showing in the phone we just want to compile and say it's done I'm good I'm living now right I'm not living sorry so yeah so this doesn't force you anything you forget the overwrite you're implementing the inflate but you're forgetting the old right and you're like cool you compile so I don't write somebody will figure out later but the good thing about coding is that it actually doesn't compile so it forces you to fix it because we always want to compile things we love to compare things in this case in our world so this is fantastic this item is obsolete now we don't need to Kirby code because the compile is actually giving its gonna force us to fix it right away so this is great for actually maintainability and readability of course please don't ignore they were right well you can't ignore it now so think thanks to Colleen this is better let's talk about the item 17 design for inheritance or else private this is another beautiful thing were in : if you try to do that by default is gonna be nope not gonna happen it forces you to actually make the decision in place hey are you sure you want to do this because it's like a bad idea you're not effective Java book this is what Collin is saying to you effective job book told us that this was not a good idea for many reasons are you sure you want to do this he's asking you do you have a percent sure about this and you're like I want to think about it and that's the whole point of these being closed by default the class is being closed by default it makes you think and actually force you to make the decision on side so because what happens on the other way around in Java is by default we don't do fine and then at some point it's too late to make it final so with this you actually need to make it explicit with the open key word and then this is okay but remember not do this instead favour composition of our inheritance because that's easy for you know you can replace implementation you can test easily you can do many things when you actually follow this item 18 so the good thing about Colleen is that it makes it easier for you so of course why not just use the nobody understands coffee machine example from Daggett and all the other dependency injection frameworks why not I actually really like espresso so this is a we're wielding here are really expensive espresso machine okay so we have you know for a machine to work you need the boiler to hit the water right and then you need the pump to actually move the word to the heat to the boiler and then if it's a dual boiler or double boiler it's great because then you can make a coffee and heat the milk at the same time this is the espresso machine you want and then because then you can do multiple at home for the family at the same time really fast really performance and then rotatory vein is like a coal vein is fantastic really good coffee gonna go out there anyway doesn't matter so imagine we wanna be less pressure coffee machine in coffee machine in java for some reason I don't know nobody cares about this but you need to implement those interfaces and then you need to build a code to inject those things into the constructor or maybe you're gonna use the area the target is great it just comes with a lot of DSL that you need to learn on everybody this tuner or the Y's that is gonna be everybody people are saying like it doesn't work for me how they fixed is and because this difficulties and it's difficult unless you're working direct so anyway if you do it manually this is the man only way to do it which doesn't scale right when you have like 20 of those doesn't scale that well but thankfully Colleen we have the delegate and then you can do okay this is pressure machine it's implementing boiler and it's delegating on the implementation double boiler do a boiler and the palm is the retro Terry Bain and this is already doing all the things that you used to do manually in Java if you go to the decompile code this wire actually generates it actual generates when this case they were I did a trick they were actually Singleton's but if it wasn't singleton it will be injected by the by the constructor so it does everything for you calling just by using the keyword by this is fantastic again this makes me happy you just need I just the more code I write the more features I create not just rid of passage around Java things so this is this makes me happy again this is item 77 don't ignore exceptions but we all ignore exceptions I do it sorry guys I do because you know seriously what do I do with this exception so I'm trying to close and it says that I can close it so what I do I do it what do we do at that point I don't know just ignore it so anyway yeah there are check exceptions in Java but they don't work so well actually with functional programming so most of the function of parameter languages decide to not have check exceptions and actually only do the same colony code lean doesn't force you to check any to try catch any exception but if you want to do it the cool thing about try and catch encoding is that it's actually an expression and you can return values from that expression so it's actually super readable right so okay let's catch this value into an int if it's an exception just a true minus one which we know is like an error or something and this is super readable or try and then catch in the return of this cool so it's done forced you to catch weird exceptions and sometimes exceptions are legit so click please catch them when they are legit but sometimes you don't know what to do with them so just don't need to do it and you can use trying catch as an expression so this item is actually improving the called in language to which again I like it because it forces me to think less about issues with the language even more about the features that I'm building then there is this item 15 which is minimize mentality please to this but then when you do this in Java then you need to obey the contract whenever writing equals and then because you have already cause you need to write hash code and it's like neverending story it's terrible so you have this again the puja this in this this in the name is item Java because job of course and we have a ID name and description and then they are immutable immutable fields so what you need to do is constructor like this where you're checking if they are not no because they need to be not no and your assignment to them but then you need to write equals because effective Java C so and you need to do it otherwise the equals one work so you need to do this and it's more lines and if it's the same reference is fine if it's not is this de instance if it's the instance then they check it all of them with too much thinking and to useless things so then remember crash code don't forget the hash code you need to multiply by a prime number and then do a cemetery of all the fields rah blah blah yeah because you one have only one equals need to have the same high school between them so that's why that's a contract you are trying to to do and you'd not you'd need to do this every single time you want to do the one of these immutable classes before that a class is it crazy so it's like a hundred something lines for nothing no feature this is no feature this is just holding the state data sorry not a state and then you go to call in and this is wonderful this is just one key were what is happening why have been doing this for 15 years I mean I mean sorry sorry now 15 there's many libraries that do that for you but they still they do have a little bit of boilerplate like how to auto value for example but this is it's just beautiful it's amazing it's a really powerful really effective one keyword gives you less the compiled this if you d compile it you get all of this for free all of these for free no error prone no human errors I make them a lot of errors so I need to triple check on my code and do three unit tests for all of them because it's really really really I'm a human sorry yeah so you know it creates for you the constructor all the Gators any tips creating things for you the equals the hash code but it creates more things it's great copy because when you have an immutable data and you want to modify some of the fields you need to copy the same the same time you are creating the new one modify the one that you actually want to be different and it does the to string to string is actually order of the effective Java items that I ignore but yeah this is good for debugging so they generate that to a string for you so you can debug religiously but there is more wait for it this is great super cheap one keyboard and you get the you you're deconstructing the class into all of the fields so you can do you know really readable code where you can actually this is classic you get a data class and you can actually you need to process many fields of it right so by doing it the construction of the data class you can actually that in one line and you it's pretty clear to me that the ID the name a description they come from this for item which I'm create on the method below and let's thank you to the data class screen the the component 1 2 3 and M depending on the fields so again one keyboard 180 lines of code for you Sedo error-prone no human ever in both here but there is more things right so if you you do Android we do under it so parcel of all is one of those beautiful things where you need to actually implement a contract but if you do it wrong you don't you don't even realize actually it's like you realize in runtime maybe sometimes you don't even realize because you get default values so unless you are checking for something really specific there or may come really late on the execution so you can never actually tied to that error on the implementation of parcel so by using the annotation per slice you can they under it call the in plugin actually generates a par syllable code for you this is great this is more free things for for one annotation I love free things is good any you know again if you if you give me five minutes to override equals and five minutes to create our beautiful UI I will take the five minutes for beautiful you I always I will actually introduced a the back on the equals I don't care about the equals now I'm just kidding Colin gives to you so that's why this is wonderful and as you can see there is a common pattern here that it seems they calling creators got really interested in effective Java and actually had many many things into the language in the core of the language so that's great for us actually that's fantastic for us so again 120 lines for one keyboard great great performance so close well he is a certainty and he was the inventor of no pointer references and in these 30 seconds that you can know here he is ending the sentence by saying well perhaps it was a billion dollar mistake yes sir it was a wonderful billion dollar mistake and we all remembered about this whatever so yeah in Java how many of you get no point exceptions every day right beautiful it's great so in actually effective Java there are many items that are all about how to handle null values and the classic one is item 43 which is if you're returning a collection and it's empty don't return on no return an empty collection please so we avoid some no pointer sessions but let's talk about the elephant in the room which is how do we handle not referencing in Java and how that changes in calling you'll know about this but I want to make a clear example of what happened to me or what happened when you work in a team with many people remote and that is a lot of code going on and you need to do many many code reviews a day most of the time I get this line of code in the code review so if you get this the signature of the method you don't have any information about the null ability of the parameter or the return value so if you're doing a collab you through a tool that doesn't have a static analysis tool static analysis jobs then you are actually you actually need to do know the code which you're gonna do anyway hopefully and run to avoid bugs but you know it's difficult for me because I don't know what's happening imagine even if that comes from a third party API where I don't have the code I don't I can not read the code so I can trust them what has happened so I always have to check defensively against know so I get this the spaghetti code where if all day if there is more if that actually featured code scrape so usually you know in when you're doing the code review is the classic okay are they are in the unity this is in Java are they having the nobility connotation are they actually favoring optionals or empty values rather than know if it's an old Easton all a possible value reaches because they forgot that the they should use the optional or the empty value of their class if it's a no lab are not possible value maybe you want to throw an exception for that too because it's an illegal argument ray so decoder bu is not about the actual feature code is about okay let's handle null pointer exceptions okay this is not it's a Caribbean but null pointers now and this happens for all the reviews and then you tried to do some nice things like this contract where I'm telling you I'm not Nolan not know but they don't enforce it it's just like this is our in understanding I'm reading your code and you're telling me and I trust you because you were with me but I want to see so even unit that's just in case you know this is this to some unit is just in case to enforce that and then you know you get an ID you don't get a compile I told you the most important thing is to compile this allows you to compile but this is gonna crash we don't want this but we ignore IV warnings yeah well we like we like to live in the on the edge and we do these things so yeah so that's the problem we are using this but this is not enforcing anything actually so this line encoding tells you exactly the anole ability of return value and parameter and that's a different my brain changes when I see calling code I don't have to care about this anymore because the compiler is gonna check it for me this means that by the fall is no no and if you want to make it neural you need to make actually you need to use your brain power say is this gonna be no do I really want to this to be no and if I want I need to actually write an extra character so it's expensive for me extra character and it's a question mark so it's like wait is the right value okay anyway so and the wonderful thing is when you go to the Java code that the compiled from these it's actually the same no no but they of course they have which they check the values before running the code of the of the function and if you are into our so when you are into doing interoperability between Java and Colleen Java doesn't ensure that so you can always pass a known but it's gonna it's gonna fail in runtime so that's that's good I at least know that we are gonna fail fast so that's why I was saying before you should don't want the code and run it just in case especially if you play with job if you have job and calling code together but this is just fantastic I do this and I get the same the same but at the same time it doesn't compile some good cycle the thing about so I just wanna the first thing my goal in life is to compile things so I'm gonna fix this issue I'm gonna be sure that I'm not personal because otherwise I cannot compare my code and that makes me happy emojis anyway let's talk about events there is a chapter in effective Java about enums all of those things which are pretty much instead of using primitives for predefined constants just use in them any type of enums so you can keep using those most of them in common but I want to talk about something more powerful they called shield classes and they represent restricted class hierarchies they're so powerful that they have some heavyweight there so the good thing about seal classes that allows you to represent after data types and with that you can imagine you have the classic presenter with the state so you could represent all the states of that screen with a seal class and it would be like a finite state machine so that's why I like seal classes it gives you more powerful we could not do this without a lot of work played in Java so for example we have this remote data class sorry seal class in mercury at the code base is an open source project actually Eid represents any network request so any network requests States right so for example what is the classic first estate not you not even initialize it's just like waiting for something to be executed and this it's a class but it could be actually an object because that it's a singleton right because not initialize means the same for all the neighbor requests it doesn't need anything specific to a different for a for a different neighbor request and then you have the class loading right this is the estate you are loading you are actually making a request and you're waiting to get all the data and that actually could be and data class because it's gonna have some value gonna have a progress that you probably want to update the UI when you get a new progress right and then the classic two results of a neighbor request is either success or either failure and if it's success you want to get the response so you can parse the data and then if it's a failure you when I get exception and you want to react depending on the exception you're getting and so this is different to an enum right you see that I can have any type of class inside the SIL class which is not possible with enums and so this allows me to represent all these states and when using that pairing it with the wine state then is when we can have fun so when we use the when as a state as a statement then order sorry as an expression then we get compiled check exhaustive sorry English is difficult compile check exhausted soft pretty much the compiler is gonna check that you are actually consuming all the values inside the cell class that's better so that means that if I modify remove data remote data and I write a new state all the places were I'm using this remote data in a when statement I'm gonna be forced by the compiler to add the new branch in that restricted class here key and that's really powerful because this is a classic where you have some state and you forget to catch the state you know like if you do this manually in Java in your presenter you're gonna add a new state and if unless you are the same right the presenter you ever done probably forget some place where we need to actually modify something this is really classy with seal classes you will get a compiler and you will be forced to update all of them so for example when we get the request and it's not initialized we just want our quest to execute when it's loading we actually wanna update the view model and say it's loading this is the percentage please update the UI what is success we want to do the same but transforming the transformation is from the request I'm gonna get the data that I really want and the UI will be updated with this and the same for the failure right when there is an error we want to say we want to show to the user some error that means something for them because I don't wanna if I may use it I want to see error or 5/3 5 2 3 4 6 because I don't know what 5 I don't even know what was it but I don't understand so you need to tell them like for this error this is the text that it's relevant for the user anyway with this if I remove or add a new class to the remote data I will be forced by the compiler to add it as some one more branch I'll let you have else if you have else then you defeat the purpose of this but you can have it as fine so if you want to check more the code is actually more extends and you have some extension functions that are really classic like you always need to transform the response into something so we have the destination function so please check it out and Kitty was actually the person who did most of the heavy lifting there I think it's very interesting a small project open source project where you can see the power of steel classes and now let's talk about genetics today there are there is actually one chapter early about generics in effective Java because they are complicated actually it took me many many years to understand anything especially the workers will talk about this so favorite generic methods we have this thing in calling code refight that is wonderful and you cannot do this in Java so give it an inline function actually in line extension function for the context you can use the type of T inside that block so that means that you can do something like this right so only you can only parry if I within line and the reason to do that is because the color in line means that sorry let's go through this so because we have in line and refi we can use the D cluster so it's going to start an activity like this right so we cannot do this in Java we try to do this in Java it will be to pass actually the class as a parameter right because we don't we cannot in Java we cannot use the type generic inside the function because the type of ratio right but the way inline functions work they get replaced by the compiler on the color side so by type inference the coding compiled it actually knows the type T and can replace T by the actual type inference T so that's why this works and this is pretty unique and pretty great and it helps you to have better API so I like so many actually hundred hundred extent Android X calling extensions right they modify some of the most difficult and we're hundred API is by using many of these type of reified functions and you can check it out it up in certain it's a really good way to see how it helps you to get better api's so this is powerful and you can only do it with colleen not with java right now there is the item 28 which is this is we're keeping talking about generics prefer least two arrays right and this makes sense for java because arrays are covariant we are getting into a body the body ends show and this is a real interesting show so we have in integer which is like a subtype of number so if you have a raise you can do this nice thing which is well not nice but you can do this thing which is assign an integer array into a number array and then you can assign a in the in the first cell you can assign a long value into that but that makes no sense because a long is not an integer so it should actually never compile but because his covariant means that the integer is objective of number but then our I of integer is a subtype of array of number two and this is the show and then what happened is you compile you're happy and then in run time it's like nope not working so that's why effective Java tells you please use list don't use this because Li is this actually invariant so that means that you can never assign a list of integer into a list of numbers and then you are not gonna have this type of issues it's gonna actually enforce the type safety on compile time we only one you know compiled nice and neat so when we enforce things and compile time we know that we are gonna be forced to fix them so this is really important that's why effective Java recommends to use lists instead of arrays and some other things too but array is encoding are actually invariant to and allow generics to so you can just use a race encoding to and it's fine it's gonna work as good as list in Java this is what it does then this is the item 3-1 which is a really difficult one because use bounded wildcards to increase the API flexibility the fact that is a wild thing this is difficult for me Wow so well anyway let's talk about this let's get this straight so the effective Java has this example a stack stack stack of E right and you want to push all and you get an interval of e this doesn't work it doesn't work when you have a stack of number and you are trying to push an integer it should work though because they are subtypes so it could be perfectly inside there so it doesn't work because the parameterized types are invariant right so similar to what we were talking before and so what's so how do we fix this right that's the question that's exactly how you fix it we don't know how to fix it so we put this it's a question extensity or eat or question super T and this is the workers then don't take this from me just go to Java documentation and it there is a link that says workers probably one of the most difficult features in Java and that's true that's in the documentation so Joshua block came up with this because what does it mean that extends from te what does it mean that is super of T well this is what it means he created pecks which stands for producer extents consumer super super that's not not great but you know it works reduce it extends consumer super ok ok so that means we were not able to do this but we can do this if we replace the e with what this eatable is doing this interval is doing is actually producing is it's producing is and we are going to add them into the stack so we just do that we just do not you know produce it extends so we're doing producer extends and this suddenly magically works it's wild it's fans're it's about joke um so you can do the same with the pop oh right the pop-up means that we are gonna add to the destination collection all the items in the stack so it's gonna be consumed super ok consumes not no it's not it's not good but it's better than nothing because workers are difficult this is called you site variance and it's called use site because it's in the it's used in the place where you are using the type right and Colleen has the same so we can do the same but in my opinion it's more readable and more understandable because they replace the question Marcus Thames and the question are super wild card Welker buy out and in and out produces things and in consumed stinks that's more like natural to me out produces in consumes right or consumer improves consumed and improves it up cool this is more readable for me I don't have to remember there is less characters to write to you know the world kind of thing so in my opinion you said balance is very in calling and more readable in nicer but then Colleen has these declarations site variance which is available in some other languages which is really interesting too because it gets annotated in the class or in the gen a or in the interface and it's a clear contract from the side of the implementer so if I have to implement source I know that it's only gonna produce T it's if I'm writing interface what I want the implementer of this interface now is that only produce T or is not gonna work that's what I'm saying right here right the same within within I'm saying I'm only consumed T so please when you implement this follow this right and again it's really easy to read out in in is more helpful because it allows the you know if you are sharing code with people when they see the interface declaration you see right away but moreover IntelliJ actually gives you that for free if you enable it it will tell you when your interface or class can actually have declaration Siberians so this is great IntelliJ will do it for you you don't have to think about it so these are generics they are beautiful they're great they're a little bit different but in my opinion they really interesting part is that you you use in and out which are more readable and then at the same time you have the declaration side variance which we never had before in Java they are actually they are actually discussing now to have it but but we know how Java goes so as I showed during the talk : it's really opinionated and brings many of the effectives you have items into the language core actually if you check effective Java now I'm probably gonna be like a really small book it's a really big book but with calling you are only gonna be able to use some of them because they are already most of them in the language and I really like what I really like about Collin is that they decided to make clear things by for example when you have to define a variable you need to actually this decide there you need to use your brain and decide this is gonna be a ball or this is gonna be a bar and they have both different intentions so you need to be sure that you're making the right decision you can change it later but that propagates down to your implementation right but it's great that you actually need to sing before and the same with Nolan no no by default is no is not no because we don't want to have no point exceptions so we should I say try to minimize notes but sometimes notes are a possible value but then they are making in a you're making the conscious decision by adding the question my right so this is a thing that really like Larry liked about calling that they create this extra key words that make more clear what you are trying to design here not only that but Colleen brings some fluency right it brings the joy of function opera me right because I mean you can do that now most of it with Java but we were stuck for a long time before we were stuck for a long time in five and six Java right and so that was not the case for Android developers you can do things like that where you get an array and then you prompt you make it a sequence and then you can filter a map and do all the thing the nice things about functional programming and then if you want to get even fancier you can use arrow which is like taking a lot of ideas from Scala from the skelewu with monads and options and tries and evolves and many more functional programming goodies and they keep working on it so this this is a definitely like even more fancy functional programming than what Collin gives you to you by before and at the end of the day is more about less boilerplate and more features right it's fluent is more readable and then I don't have to write so much water play because the language is already thinking about me how to make things faster and better not only that but it comes with IntelliJ which they are the same people so of course it pairs really well together and it gives you it gives you it keeps give you good giving you good is like the the fact that they can infer if you need to put in and out for example in classes that's a really nice thing to have then we have Landa's expression well this is nothing special it's marketing templates typing friends type Ollie's I like that balance deputies are great when you know when I was sitting at the beginning I they talked about we always make mistakes if we have the same parameter types we type Aaliyah's you can still use the same type parameter but saying type alias ID equal string and then suddenly the ID it's an ID type but still underlying type is a string but you can never swap now description with ID anymore because they are different type so that's the ballast that's good then the rate expressions that I show in the slide before you can overload the operators which is yet companion objects core routines which is interesting we'll see what it goes it's a different threading model so I actually want to talk about core routines because there is a whole chapter about threading an effective job and I wanted to compare it with co-routines but that actually took two hours so I was like no I don't think we are gonna have time to do this so maybe I know I talked and then I'd really like contracts the fact that we can overwrite the compiler decision to say no no no I know more than you let me do this I get this and this is coming now and in line classes is coming now - you know they keep just bringing more goodies and more interesting things that are gonna make our development much easier and productive and effective so I guess the question is why we're still using Java and again I want actually to pay a tree with the Java because so job is not going anywhere actually it's actually most of the backends are having written in Java and they're gonna be I think still for many years to be in Java because Java has a big tooling big libraries that were really really well and there is not actually incentive for you as a company to replace something that works for you even if developers know is like better this this language it makes me happy well happiness it's not a measurable with money so the company well this is a really difficult system why are we gonna replace it with a Colleen when it has three years old language and I mean so it's gonna be run so don't forget about Java in Java straight because of effective Java in Java we were able to see how calling learned from that and how we are we are all learning from that too so I'm expecting soon that we have an effective Colleen look because I guess we need to start getting effective calling practices because there are a lot of things that can go wrong in Colleen too but I guess I want to power everybody to just call him because it's really a joy of a language and keep pushing in your companies to use calling and thank you for coming I hope you learn something and you like the talk and see you are [Applause] you

Channel: droidcon SF

Views: 1,843

Keywords:

Id: SFZRYoDh5pM

Length: 42min 52sec (2572 seconds)

Published: Fri Nov 30 2018