Best match

Most recent

Personal computer

In 1979, two M.I.T. computer-science alumni and a Harvard Business School graduate launched a new piece of computer software for the Apple II machine, an early home computer. Called VisiCalc ...

The Birth of the Personal Computer

The New Yorker

Others offer a seamless and responsive experience, letting you do everything on a mobile device that you would on a computer. Don't commit to CRM software until you've used the mobile app in a way ...

The Best CRM Software for 2023

PC Magazine

Antivirus software

The best antivirus software can help keep your Windows computers protected against malware and other cyber threats. Although Microsoft's Windows Defender antivirus may be enough to keep your PC ...

The best antivirus software 2023: Free and paid options

Tom's Guide

Our PC storage drives won’t last forever and that’s why it’s always a good idea to use backup software to keep your data safe. The best Windows backup software can cover our butts when our ...

Best Windows backup software 2023: Don’t risk it!

PC World

Here’s our detailed list of the best antivirus for gaming: Bitdefender is overall the best gaming PC antivirus software that offers an automatic gaming mode. Its feature-rich antivirus protection suite and excellent prices make this provider a well ...

Best antivirus software for gaming PC in 2023

cybernews

Macintosh

Software

That's why having a dedicated Mac antivirus program is crucial for your MacBook, Apple computer, or any Mac device. Even though built-in antivirus can minimize the risk, it cannot provide all-around protection. Premium Mac antivirus software with ...

Best Mac antivirus software in 2023

Microsoft Windows

Even though Windows Defender has improved significantly, you may still want some extra protection for your PC in addition to Microsoft’s own antivirus software that ships with Windows.

The best Windows 10 antivirus software in 2023

Payroll

It does this through a combination of self-service computer software for easier employee management, to personalized support to ensure you're getting the help you need. Performance management also ...

Best payroll software for small business in 2023

TechRadar

Sound

Out-of-this-world sounds from other planets have been created using state-of-the-art computer software. The new technology could help in the search for alien life, scientists say. British ...

New computer software creates out-of-this-world sounds from other planets

KTBS

To find the very best antivirus software for your PC, we bombard free and paid-for antivirus software with tens of thousands of threats in our tests, including viruses, ransomware and phishing attacks designed to compromise and steal data. We repeat this ...

Best antivirus software 2023: Which? Best Buys and expert buying advice

Which

Get the most recent info and news about Altova on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Altova, Inc. designs and develops software. The Company offers mobile, desktop development, server software products, and regulatory solutions. Altova serves clients worldwide.

Altova

Bacteria: Chapter II - BACTERIA IN WATER

The OWASP Top 10 is a standard awareness document for developers and web application security. It represents a broad consensus about the most critical security risks to web applications. In this article, I want to cover the second part of the TOP 10 vulnerabilities and how to protect against them using .NET. 6. Security Misconfiguration Security misconfiguration can happen at any level of an application stack, including the network services, platform, web server, application server, database, frameworks, custom code, and pre-installed virtual machines, containers, or storage. Such flaws frequently give attackers unauthorized access to some system data or functionality. What to do? (When using TLS) Redirect a request made over Http to https: app.UseHttpsRedirection(); //Startup.cs Send the anti-forgery token with every POST/PUT request: To automatically validate all requests other than GET, HEAD, OPTIONS and TRACE you need to add a global action filter with the attribute inside your Startup.cs AutoValidateAntiforgeryToken services.AddMvc(options =>
{
    options.Filters.Add( AutoValidateAntiforgeryTokenAttribute());
}); new If you need to also validate the token on GET, HEAD, OPTIONS or TRACE - requests you can add the attribute to the controller method (for MVC controllers) or parent class (for Razor pages): ValidateAntiforgeryToken [ ]
[ ] HttpGet ValidateAntiforgeryToken IActionResult ( ) public DoSomethingDangerous [ ]
[ ] : HttpGet ValidateAntiforgeryToken public class SafeModel PageModel In case you can't use a global action filter, add the attribute to your controller classes or razor page models: AutoValidateAntiforgeryToken [ ] AutoValidateAntiforgeryToken public class UserController [ ] : AutoValidateAntiforgeryToken public class SafeModel PageModel 7. Cross-Site Scripting (XSS) XSS is the second most prevalent issue in the OWASP Top 10, and is found in around two-thirds of all applications. The impact of XSS is moderate for reflected and DOM XSS, and severe for stored XSS, with remote code execution on the victim’s browser, such as stealing credentials, sessions, or delivering malware to the victim. What to do? DO NOT: Trust any data the user sends you, prefer white lists (always safe) over black lists DO NOT: Use the [AllowHTML] attribute or helper class @Html.Raw unless you really know that the content you are writing to the browser is safe and has been escaped properly. 8. Insecure Deserialization The impact of deserialization flaws cannot be overstated. These flaws can lead to remote code execution attacks, one of the most serious attacks possible. What to do? Validate User Input Malicious users are able to use objects like cookies to insert malicious information to change user roles. In some cases, hackers are able to elevate their privileges to administrator rights by using a pre-existing or cached password hash from a previous session. Prevent Deserialization of Domain Objects Run the Deserialization Code with Limited Access Permissions If a deserialized hostile object tries to initiate a system processes or access a resource within the server or the host's OS, it will be denied access and a permission flag will be raised so that a system administrator is made aware of any anomalous activity on the server. Don't allow the datastream to define the type of object that the stream will be deserialized to. You can prevent this by for example using the DataContractSerializer or XmlSerializer if at all possible. Where JSON.Net is being used make sure the TypeNameHandling is only set to None. TypeNameHandling = TypeNameHandling.None If JavaScriptSerializer is to be used then do not use it with a JavaScriptTypeResolver. If you must deserialise data streams that define their own type, then restrict the types that are allowed to be deserialized. One should be aware that this is still risky as many native .Net types potentially dangerous in themselves. 9. Using Components with Known Vulnerabilities Prevalence of this issue is very widespread. Component-heavy development patterns can lead to development teams not even understanding which components they use in their application or API, much less keeping them up to date. While some known vulnerabilities lead to only minor impacts, some of the largest breaches to date have relied on exploiting known vulnerabilities in components. What to do? Keep the .Net framework updated with the latest patches Keep your packages up to date, many will contain their own vulnerabilities. NuGet Run the against your application as part of your build process and act on any high level vulnerabilities. OWASP Dependency Checker 10. Insufficient Logging & Monitoring Attackers rely on the lack of monitoring and timely response to achieve their goals without being detected. Most successful attacks start with vulnerability probing. Allowing such probes to continue can raise the likelihood of successful exploit to nearly 100%. What to do? Ensure all login, access control failures and server-side input validation failures can be logged with sufficient user context to identify suspicious or malicious accounts. Establish effective monitoring and alerting so suspicious activities are detected and responded to in a timely fashion. Log all errors from the Startup.cs, so that anytime an error is thrown it will be logged. { (env.IsDevelopment())
    {
        _isDevelopment = ;
        app.UseDeveloperExceptionPage();
    } app.UseExceptionHandler(errorApp =>
    {
        errorApp.Run( context =>
        { errorFeature = context.Features.Get<IExceptionHandlerFeature>(); exception = errorFeature.Error;

            Log.Error(String.Format( , exception.StackTrace.ToString()));
        });
    });

    app.UseAuthentication();
    app.UseMvc();
} ( ) public void Configure IApplicationBuilder app, IHostingEnvironment env if true //Log all errors in the application async var var "Stacktrace of error: {0}" Monitor key performance indicators. In .NET a great option to add monitoring capabilities is . Application Insights Thanks for reading! - Part one https://hackernoon.com/owasp-top-10-net-protection-a-guide-part-1-w92r3wis P - Read more about OWAS https://owasp.org/www-project-top-ten/

OWASP Top 10 .NET Protection Guide (Part 2)

When you tend to use one library for a certain period of time, you get used to it. But, you need to evolve and learn something new every day. If you are still stuck up with Matplotlib(Which is amazing), Seaborn(This is amazing too), Pandas(Basic, yet easy Visualization) and Bokeh, You need to move on and try something new. Many amazing visualization libraries are available in python, which turns to be very versatile. Here, I’m going to discuss about these amazing libraries: Plotly Cufflinks Folium Altair + Vega D3.js (My best Pick, i code in JS too) If you are aware and use the libraries mentioned above then you are on the right track of evolution. They can help in generating some amazing visualizations and syntax ain’t difficult too. Generally, I prefer more of plotly+cufflinks and Alright, lets get back to the basics: D3.js. Plotly Plotly is an open-source, interactive and browser-based graphing library for ython. Plotly is a library that allows you to create interactive plots that you can use in dashboards or websites (you can save them as html files or static images). Plotly is built on top of plotly.js which in turn is built on D3.js and it is a high-level charting library. plotly comes with over 30 chart types, including scientific charts, statistical charts, 3D graphs, financial charts and more. The best things about plotly is that you can use it in Jupyter Notebooks, as well as stand alone HTML pages. You can also use it online on their site but i prefer more to use it offline and you can also save the visualization as an image. It’s pretty simple to use it and get it to work. — Method to use it in Jupyter Notebook (Offline) First, install the plotly library. pip install plotly Then open jupyter notebook and type this: from plotly import __version__
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True) The syntax is quite simpler or simplest, i say? In P_andas_, you use and here, you use This changes the whole definition of the visualization. dataframe.plot() dataframe.iplot(). “ i ” With just one line, i generated this scatter plot. You can customize it as you want. Remember to specify mode markers or you’ll just get some cluster of lines. Scatter plot generated using plotly Please note that as the data increases, plotly begins to choke. So, I would only use plotly when I have less than 500K data points. Try it all in your Jupyter Notebook. Cufflinks Cufflinks binds Plotly directly to pandas dataframes. The combination is just amazing, the power of plotly combined with flexibility of Pandas. It is more effective than plotly. The syntax is even simpler than plotly. With plotly’s Python library, you can describe figures with DataFrame’s series and index, but with cufflinks you can plot it directly. Here is an example: df = cf.datagen.lines()

py.iplot([{
    'x': df.index,
    'y': df[col],
    'name': col
}  for col in df.columns]) With Plotly df.iplot(kind='scatter') With Cufflinks Cufflinks makes it much easier to plot stuffs. You can also generated amazing 3D charts with cufflinks too. I have generated this 3D with just couple of lines of code. 3D chart with Cufflinks You can always try it out in your Jupyter Notebook. — Quick Hack: Set in the config: c.NotebookApp.iopub_data_rate_limit = 1.0e10 Import it the following way: import plotly.graph_objs as go
import plotly.plotly as py
import cufflinks as cf
from plotly.offline import iplot, init_notebook_mode
cf.go_offline()
# Set global theme
cf.set_config_file(world_readable=True, theme=’pearl’, offline=True)
init_notebook_mode() And it works inline. Next, I’m going to talk about yet another amazing Viz library. Folium Folium is built on the data wrangling strengths of the Python ecosystem and the mapping strengths of the Leaflet.js library. You can manipulate your data in python, then visualize it in a Leaflet map via folium. Folium is turning out be an amazing library for plotting spatial data. You can also generate heat maps and choropleth maps using folium. Let’s learn something about folium: Maps are defined as a object, addition of other folium objects on top of the to improve the map rendered folium.Map folium.Map can be done You can use different map tiles for the map rendered by Folium, such as MapBox, OpenStreetMap , and several other tiles, for that you can visit or . this github repo folder this documentation page You can also select different map projections. Many projections are available out there. Let’s generate a Choropleth map with Geojson of US unemployment. Here is the snippet: map = folium.Map([43, -100], zoom_start=4)

choropleth = folium.Choropleth(
    geo_data=us_states,
    data=state_data,
    columns=['State', 'Unemployment'],
    key_on='feature.id',
    fill_color='YlGn',
    name='Unenployment',
    show=False,
).add_to(m)

# The underlying GeoJson and StepColormap objects are reachable
print(type(choropleth.geojson))
print(type(choropleth.color_scale))

folium.LayerControl(collapsed=False).add_to(m)

map.save(os.path.join('results', 'GeoChoro.html'))

map This is just a basic one, you can add markers, pop ups and a lot more to it. Here is how it would look like. Map with leaflet and folium Altair + Vega Altair is a declarative statistical visualization library and it is based on Vega and Vega-Lite. Altair enables you to build a wide range of statistical visualizations quickly with a powerful and concise visualization grammar. You need to install it the following way, if you are using Jupyter Notebook. It also includes some example vega datasets. pip install -U altair vega_datasets notebook vega Altair’s main dependency is Vega, in order to make the plots to be visible on the screen, you need to install it and also, you need to run this command for every new session. alt.renderers.enable(‘notebook’) Data in Altair is built around the Pandas Dataframe. One of the defining characteristics of statistical visualization is that it begins with tidy Dataframes. You can also save the plot as an image or open it in vega editor for more options. It’s definitely not the best one out there, but definitely worth a try for the sake of creators hard work. Here is an example, I’m using cars dataset for this; import altair as alt
from vega_datasets import data

source = data.cars()

brush = alt.selection(type='interval')

points = alt.Chart().mark_point().encode(
    x='Horsepower:Q',
    y='Miles_per_Gallon:Q',
    color=alt.condition(brush, 'Origin:N', alt.value('lightgray'))
).add_selection(
    brush
)

bars = alt.Chart().mark_bar().encode(
    y='Origin:N',
    color='Origin:N',
    x='count(Origin):Q'
).transform_filter(
    brush
)

alt.vconcat(points, bars, data=source) Scatter plot and Histogram with Altair and Vega You can try it out in your own Notebook and let me know if you get stuck anywhere! D3.js (Data Driven Documents) is a JavaScript library for manipulation of documents based on the data. You can bring data to life using HTML, SVG, and CSS. D3 does not require you to tie tie yourself to any proprietary framework because modern browsers have it all that D3 needs and it is also used for combining powerful visualization components and for a data-driven approach to DOM manipulation. D3.js D3.js is the best data visualization library out in the market. I prefer to use it almost every time. You can use it with python and as well as with R. Originally, it works with JavaScript and that becomes quite tough because JS has wide range of functions and requires much learning and experience but if you are a JS pro then you don’t need to make a second thought. Although, and has made it a bit simpler, just a bit! But you get the best stuff out there with this library. Python R D3py has 3 three main dependencies: Numpy Pandas NetworkX I would suggest you to use it with JavaScript or R, not with python because the version is out of date and was last updated in 2016. Though, it was just a thin python wrapper for D3.js. R has an interface for D3 visualizations. With , you can bind data from R to D3 visualizations. D3 visualizations created with work just like R plots within RStudio, R Markdown documents, and Shiny applications. You can install the package from CRAN as follows: r2d3 r2d3 r2d3 install.packages(“r2d3”) You can make some amazing visualizations with this one, Let me show you a couple of it here. Sequences Sunburst — ’s Block (Source) Kerry Rodden Activity Status of an Year — Kunal Dhariwal (Me, lol) From basics to High end, you can build anything with D3.js, Don’t forget to try it out. If you encounter any error or need any help, you can always make a comment or ping me on LinkedIn. : LinkedIn https://bit.ly/2u4YPoF : Github https://bit.ly/2SQV7ss P.S- Special Thanks to the creators and contributors of those amazing libraries. I hope that this has helped you to enhance your knowledge base :) Follow me for more! Thanks for your read and valuable time!

Taking Data Visualization to Another Level

Borrowing-to-lend for loan-to-buy customers Toyota Financial Services has to be one of the most fascinating, fraudulent entities operating in the world right now. Initially fuelled by cheap Japanese interest rates when it was first begun in the early 2000s, this “ within a factory” is one of the world’s most opaque, byzantine and powerful global financing organisations that you have never heard of. bank Today, TFS is the focus of Toyota’s operations, issuing billions in zero percent and cut-rate financing offers a year and guzzling a similarly sizeable chunk of money from the fixed income markets. Take, for instance, the company’s 50 billion euro note issuance last September. This was a collaboration between no less than 7 issuers spanning four continents all organised under the giant TFS banner. Not content with borrowing in just euros and yen, in July this earlier, Toyota issued its first dollar-denominated bonds: $2 billion of 3-, 5-, and 10-year commercial paper. That quick capital raise was shortly followed up with a further $3 billion issuance of USD-denominated retail notes aimed at American private investors — debt that your mother and father might put their savings into. The retail notes are “a way to expand and diversify TFS’ funding sources and provide a competitive investment alternative to investors,” Mike Groff, TFS’s new President, at the time. said in a press release That’s not all, though — there are the for environmentally-conscious lenders (a cool $5.5 billion), , another , and there was even a . Oh, not to mention lending the company solicits, too. Plus the standard fare of Japanese long bonds and other debt tranches the company issued this year via its myriad network of franchisors. By all accounts, it all adds up to a sizeable chunk of borrowing, representing more than 3 times the company’s steadily relaxing net income. green bonds the 2021 $750m 3.183% yield debt 300 million euros of 3-year debt $300 million 1-year tranche which redeems this month the $500 million of overnight The recent borrowing splurge is yet another unconventional policy play from Akio Toyoda, the current chief executive of Toyota since 2009. Toyoda is the third-generation heir to the family empire. It was his own grandfather Sakichi Toyoda, no less, the company’s founder, who once famously quipped, “it is more difficult to spend than to earn money.” That was back when the company used to stockpile cash and amortise loans before the year was up. How times have changed. , TFS launched a new office earlier this year, alongside a handful of other countries which saw the manufacturer’s finance empire expanding. However, investors might be forgiven for wondering where all this borrowing is going. After all, Koji Kobayashi, Toyota’s chief financial officer and an executive vice president, told Toyota’s November earnings conference attendees that he intended to cut costs by another full 50% over the coming year. In Ireland manufacturing “It would be good if our annual cost savings could reach 600 billion yen ($5.3 billion),” Koji-san , expressing concerns at what he forecast as “difficult” conditions for the company going ahead. That was despite having posted a record net profit on industry-wide record profit margins. (Toyota’s margins, at 8.9% trounce Honda’s, at around 6%, and Ford’s, which are as low as 3%.) said at the time , where Toyota Motor has a rather less well-respected reputation, may offer some insight into where all this debt is headed. The Japanese auto-maker laid off 50,000 factory workers in Altona a few years ago, many of them entire families. Needless to say, the effect on sales was felt across the 400-odd dealership franchises throughout the country, denting the company’s usually PR-self-conscious image badly. (Aussies tend not to forgive and forget too quickly if you fuck them.) The challenge has been — how to get sales back on track? A peek at Australia “At the moment, the (dealer) reputation may not be too great but I think we can turn that around and we think this is the way to do it. So we are pretty positive about this,” TFS president and CEO John Chandler told about the company’s latest sales-side innovation: an algorithm-based credit-matching engine. The algo, which is essentially nothing more complex or fancy than what a bank uses to credit score you for a loan, is, according to Mr. Chandler, the company’s best potential bet yet in getting sales back on track: GoAutoNews Premium “We are seeing some dealers talking of putting the finance decision earlier in the sales process,” he said. “When they can integrate that into the early discussion, particularly quoting the rates, that will become part of the whole process and we won’t necessarily have to hand the customer over to the finance guy at the end of the sales part. Affordability is a key part of the decision.” Of course, giving customers wads of cash to buy your products so that they end up paying you more on the back end is all very well, but when you are borrowing chunks of cash to do so that is rather a different proposition, surely? At that point, not only are you exposing the investor in the bond to the credit risk of the corporation and its technology systems, but you are actually exposing them to the credit risk of the borrower. More importantly still, to what extent does the manufacturer have an incentive to make sure that such loans are profitably issued? That will be the subject of our next post on this topic.

Financing The Factory Bank

Me, trying to convince Android team to use Kotlin Nearly 2 years ago our team decided to try something new: develop a commercial application entirely in , a language by JetBrains. At that time, we had experience with Kotlin but on a much smaller scale: converting some parts of apps to a new language or trying it on pet projects. However, developing a commercial application in a new programming language introduces some difficulties: Kotlin programming We were deeply rooted in Java-based Android development. Switching to Kotlin was rather difficult, especially for developers without prior functional programming experience Some stuff just doesn’t work. Dagger did not work well from out of the box All that may lead to missed delivery dates and stability issues of the application. One should have strong incentives to make the transition. Our incentive was the belief that And that it’s Kotlin would be the game changer for the Android Platform development. Fun. Keeping the Kotlin reference open, we started to develop the Kotlin is a JVM language with 100% Java interoperability, and if you’re familiar with Java, learning Kotlin is easy. However, if you want to fully take advantage of the language, understanding functional programming concepts is essential. Voter application. Learning Functional Programming takes a while. So be patient. And Functional Programming is not easy. At least in the beginning. Until it becomes fun. I strongly advise to take a . Scala can be overwhelming at times, but it gives a great overview of the new functional programming mindset. You can treat Kotlin as a simpler version of Scala. set of courses by Martin Ordersky “Functional Programming in Scala” What made us turn to the Kotlin side Functional programming style Kotlin is 100% interoperable with Java. Also, Kotlin is a functional language. And the latter allows writing more elegant, expressive code. Function purity The concept of a pure function (a function that does not have side effects) is the most important functional concept which allowed us to greatly reduce code complexity and get rid of most mutable states. In Imperative Programming Languages such as Javascript, Java, and C#, Side Effects are everywhere. This makes debugging very difficult because a variable can be changed anywhere in your program. So when you have a bug because a variable is changed to the wrong value at the wrong time, where do you look? Everywhere? That’s not good. Note that how we manipulate data without changing its content. 2. Higher-order functions Higher-order Functions either take functions as parameters, return functions or both. Higher-order functions are everywhere. You just pass functions to collections to make code easy to read. reads like plain English. Isn’t it wonderful? titles.map { it.toUpperCase()} Let’s imagine a situation where we want to count the number of unread messages of different types. A typical approach would be: As you can see, as new requirements are introduced, the code becomes unreadable and unmanageable. Let’s see how we can solve this problem with higher-order functions: And we can imagine use cases where we would want to parametrize the function argument, let’s say, for calculating the product of unread messages. fold Another example of using higher-order functions is replacing numerous Listeners with simple higher-order function: BillingView : LinearLayout { var billingChangeListener: (() -> Unit)? = null... } ... // in an activity far, far awaybillingView.billingChangeListener { updateUI() } **3. Immutability**Immutability makes it easier to write, use and reason about the code (class invariant is established once and then unchanged). The internal state of your app components will be more consistent. Kotlin enforces immutability by introducing keyword as well as Kotlin collections, which are immutable by default. Once the or a collection is initialized, you can be sure about its validity. (See UPD for more accurate definition on keyword). val val val data class Address(val line1: String, val city: String) items = listOf(Address("242 5th St", "Los Angeles"),   Address("Dovzhenka St. 5", "Kiev")) val Null-safety This language feature made us think carefully about nullability of fields in our model classes. Previously, you were not sure whether field in DTO is initialized or not, @Nullable and @NotNull annotations helped, but not as much. Now, with Kotlin, you precisely know what field can be null, what field is are initialized later (e.g. fields injected by Dagger) and you get strict control over those fields. Result? Almost no . (Internally we call a “ ” operator, because it looks like a goose’s neck) NullPointerExceptions ?. goose brand?.let { badge.enabled = brand.isNewBadge }// Can also be written asbadge.enabled = brand?.isNewBadge?:false Anko Anko DSL is a great library which significantly simplifies working with views, threads, and android lifecycle. The Github description states that Anko is “Pleasant Android application development” and it truly proved to be so. Note that when is called inside Activity, the block will not execute if is . We do not actually use this feature, as RxJava handles all the threading in our apps, but it is a nice feature. uiThread isFinishing true . Although Anko is not ready to replace standard Android UI building, sometimes it is very handy. Using Anko instead of XML As you can see, Anko DSL allows you to use custom views alongside Android built-in views. This is where it has a great advantage over standard XML. Kotlin Android extensions: Removing ButterKnife dependency In Kotlin, you don’t need any of those. You can just reference your view property by its @id XML parameter, those properties would have the same name as declared in your XML file. More info can be found in . Bored yet? I bet you scrolled that without reading. official docs Other neat features Extension functions & Builders , , and extension functions can be easily used to create elegant builders. apply let **2. A quick hack for beginners**During the first couple of days, you often stumble upon a problem: you don’t know how to write a rather simple Java expression in Kotlin. A simple trick is to write a piece of code in Java and then paste it into a Kotlin file. Thanks to guys in JetBrains, it gets automatically converted to Kotlin. Hacky, but works like a charm! **3. Getting rid of unnecessary dependencies**Kotlin replaces a lot of third-party libraries, such as ButterKnife, Google Autovalue, Retrolambda, Lombok and some of the RxJava code. Summary As a software development team, the main challenge we have is delivering great products and being effective at getting the job done. Although to start developing effectively in Kotlin you need some prerequisite knowledge of functional programming, investing time to learn it really pays off. I believe Kotlin is a major improvement over conventional Android development, which allows us to deliver great apps on time, and with MUCH fewer bugs. Feel free to ask questions, we will be grad to help others make the transition. Share your thoughts / comments below! Programming is the most fun you can have with your clothes on. John Guttag UPD: _val_ does not actually mean ‘immutable’, but rather ‘read only’. See this article for details. This post was originally published at . Follow us for more articles on how to build great products 💪 UPTech Team blog References Kotlin Reference So You Want to be a Functional Programmer Why Functional Programming Matters 6 Benefits of Programming with Immutable Objects in Java Anko DSL vs Android XML-First Lessons from converting an app to 100% Kotlin . 99.8% crash-free users. Result: Voter Application Kotlin: val does not mean immutable, it just means readonly

Why we choose Kotlin for creating Android apps

Photo by David Marcu Now that and are out, it’s a good time to revisit how the two major open source relational databases compete against each other. MySQL 8 PostgreSQL 10 Before these versions, the general perception has been that while Postgres is superior in feature sets and its pedigree, MySQL is more battle tested at scale with massive concurrent reads /writes. But with the latest releases, the gap between the two has gotten significantly narrowed. Feature Comparison Let’s take a look at the “trendy” features that we all love to talk about. It used to be easy to say that MySQL works best for online transactions, and PostgreSQL works best for analytical processes. But not anymore. Common Table Expressions (CTEs) and window functions have been the main reason to choose PostgreSQL. But now, traversing an table recursively with a reference to the in the same table, or finding a median value (or 50% percentile) in a sorted result are no longer a problem on MySQL. employees boss_id Lack of configuration flexibility with replication on PostgreSQL was the reason why . But now with logical replication, zero downtime upgrade is possible by creating a replica with a newer version of Postgres and switching over to it. Truncating a stale partition in a huge time-series event table is much easier, too. Uber switched to MySQL In terms of features, both databases are now on par with each other. Where are the differences? Now, we are left with a question — what are the reasons to pick one over the other, then? is one of those factors. MySQL has a vigorous ecosystem with variants such as MariaDB, Percona, Galera, etc. as well as storage engines other than InnoDB, but that can also be overwhelming and confusing. Postgres has had limited high-end options, but that will change with new features introduced with the latest version. Ecosystem is another factor. Everyone feared when Oracle (or originally, SUN) bought MySQL, that they would ruin the product, but that hasn’t been the case so far for the past ten years. In fact, the development accelerated after the acquisition. Postgres has a solid history of working governance and collaborative community. Governance don’t change often, and it’s worth revisiting as those aren’t discussed much in detail these days. Architectural fundamentals Here’s a refresher: Process vs Thread As to establish a connection, it can take . The memory pressure is bigger compared to MySQL’s thread-per-connection model, where the default is at 256KB on 64-bit platforms. (Of course, thread-local sort buffers, etc. make this overhead less significant, if not negligible, but still.) Postgres forks off a child process up to 10 MB per connection stack size of a thread Even though saves some of the shared, immutable memory state with the parent process, the basic overhead of being a process-based architecture is taxing when you have 1,000+ concurrent connections, and it can be one of the most important factors for capacity planning. copy-on-write That is, say if you run a Rails app on 30 servers, where each has 16 CPU cores and 32 Unicorn workers, you have 960 connections. Probably less than 0.1% out of all apps will ever reach beyond that scale, but it’s something to keep in mind. Clustered Index vs Heap Table A is a table structure where rows are directly embedded inside the B-tree structure of its primary key. A (non-clustered) heap is a regular table structure filled with data rows separately from indexes. clustered index With a clustered index, when you look up a record by the primary key, a single I/O will retrieve the entire row, whereas non-clustered always require at least two I/Os by following the reference. The impact can be significant as foreign key reference and joins will trigger primary key lookup, which account for vast majority of queries. A theoretical downside of clustered index is that it requires twice as many tree node traversal when you query with a secondary index, as you first scan over the secondary index, then walk through the clustered index, which is also a tree. But given a modern to have an auto-increment integer as a primary key¹ — it’s called a — it is . It is more so if you do a lot of to retrieve the most recent (or oldest) N records, which I believe applies to most. convention surrogate key almost always desirable to have a clustered index ORDER BY id [1] UUID as a primary key is a terrible idea, by the way — cryptographic randomness is utterly locality of reference, hence the performance penalty. designed to kill Postgres does not support clustered index, whereas MySQL (InnoDB) does not support heap. But either way, the difference should be minor if you have a large amount of memory. Page Structure and Compression Both Postgres and MySQL have page-based physical storage. (8KB vs 16KB) From Introduction to PostgreSQL physical storage On PostgreSQL, the page structure looks like the image on the left. It contains some headers which we are not going to cover here, but they hold metadata about the page. Items after the header is an array identifier composed of pairs pointing to tuples, or data rows. Keep in mind on Postgres, multiple versions of the same record can be stored in the same page in this manner. (offset, length) MySQL’s tablespace structure is similar to Oracle’s in that it has multiple hierarchical layers of segment, extent, page and row. Also it has a separate segment for UNDO, called “rollback segment.” Unlike Postgres, MySQL will keep multiple versions of the same record in a separate area. A row must fit in a single page on both databases, which means a row must be smaller than 8KB. (At least 2 rows must fit in a page on MySQL, which coincidentally is 16KB / 2 = 8KB) So what happens when you have a large JSON object in a column? Postgres uses , a dedicated shadow table storage. The large object is pulled out when and only when the row and column is selected. In other words, a large chunk of black box won’t pollute your precious cache memory. It also supports compression on the TOASTed objects. TOAST MySQL has a more sophisticated feature called , thanks to the contribution from a high-end SSD storage vendor, . It is specifically designed to work better with SSDs, where write volume is directly correlated to the device’s lifetime. Transparent Page Compression Fusion-io Compression on MySQL works not only on off-page large objects, but on all pages. It does that by using hole punching in a , which is supported by modern filesystems such as or . sparse file ext4 btrfs For more details, see: Significant performance boost with new MariaDB page compression on FusionIO Overhead in UPDATEs Another feature that is often missed, but has a major impact on performance and is potentially the most controversial topic, is UPDATEs. It was another reason why Uber switched away from Postgres, which provoked many Postgres advocates to refute it. MySQL Might Be Right for Uber, but Not for You A PostgreSQL Response To Uber (PDF) Both are databases that keep multiple versions of data for . MVCC isolation To do that, Postgres keeps old data in the heap until VACUUMed, whereas MySQL moves old data to a separate area called rollback segments. On Postgres, when you try to update, the entire row must be duplicated, as well as an index entry pointing to it. This is partly because Postgres does not support clustered index, the physical location of a row referenced from an index is not abstracted out by a logical key. To solve this problem, Postgres uses to not update index when it’s possible. But if updates are frequent enough (or if a tuple is large), the history of tuples can easily flow out of the page size of 8KB, spanning multiple pages and limit the effectiveness of the feature. The timing of pruning and/or defragmenting depends on the heuristics. Also, setting less than 100 kills space efficiency — a hard trade-off that you shouldn’t worry about at a table creation time. Heap Only Tuples (HOT) fillfactor This limitation goes even deeper; because the index tuples do not have any information about transactions, it had long been impossible to support until 9.2. It’s one of the oldest, most important optimization methods supported by all major databases including MySQL, Oracle, IBM DB2 and Microsoft SQL Server. But even with the latest version, Postgres can’t fully support Index-Only Scans when there are a bunch of UPDATEs that set dirty bits in , and often choose Seq Scan when we don’t want. Index-Only Scans Visibility Map On MySQL, updates occur in-place, and the old row data is stashed in a separate area called rollback segment. The consequence is that you don’t need VACUUM, and commits are very fast while rollbacks are relatively slow, which is a preferable trade-off for majority of use cases. It is also to purge history as soon as possible. If the isolation level of a transaction is set as or lower, the history is purged when the statement is completed. smart enough READ-COMMITTED The size of transaction history does not affect the main page. Fragmentation is a non-issue. Hence the better, more predictable overall performance on MySQL. Garbage Collection VACUUM on Postgres is very costly as it works in the main heap area, creating a direct resource contention. It feels exactly like a garbage collection in programming languages — it gets in the way and gives you pause at random. for a table with billions of records remains a challenge. Configuring autovacuum Purge on MySQL can also be heavy, but as it runs with dedicated threads inside the separate rollback segment, it does not adversely affect the read concurrency in any way. It’s much less likely that bloated rollback segments slow you down, even with the . default settings A busy table with billions of records does not cause history bloat on MySQL, and things such as file size on storage and query performance are pretty much predictable and stable. Logs and Replication Postgres has a single source of truth for transaction history called . It is also used for replication, and the new feature called Logical Replication decodes the binary content into more digestible logical statements on the fly, which allows fine-grained control over the data. Write Ahead Log (WAL) MySQL maintains two separate logs: 1. InnoDB-specific for crash recovery, and 2. for replication and incremental backup. redo logs binary log Redo logs on InnoDB are, as with Oracle, a maintenance-free that won’t grow over time, and only created at a fixed size at the boot time. This design guarantees that a sequential, consecutive area is reserved on the physical device, which leads to a higher performance. Bigger redo logs yield higher performance, at the cost of recovery time from crash. circular buffer With the new replication features added to Postgres, I’d call it a tie. TL;DR Surprisingly enough, it turns out that the general perception still holds; MySQL works best for online transactions, and PostgreSQL works best for append only, analytical processes such as data warehousing². [2] When I say Postgres is great for analytics, I mean it. In case you don’t know about , it’s a wrapper on top of PostgreSQL that allows you to INSERT 1 million records per second, 100+ billion rows per server. Crazy stuff. No wonder why . TimescaleDB Amazon chose PostgreSQL as its base for Redshift As we saw in this article, vast majority of complications with Postgres stem from its append-only, overly redundant heap architecture. Future versions of Postgres will probably require a major revamp of its storage engine. You don’t have to take my word for it — it’s actually , which suggests that it’s time to take some good ideas back from InnoDB. discussed on the official wiki It’s been said time and time again that MySQL is playing catch-up with Postgres, but this time, the tide has changed. If you want to read more like this, visit Dumper Blog and subscribe to the mailing list. You can also follow me on Twitter. Unless you are 100% sure that your backup scripts are working, check out Dumper , offsite backup as a service.

Showdown: MySQL 8 vs PostgreSQL 10

Put your Android Development in Nitro Mode When was announced as a first class language for Android at , I made it my top priority to dive into the depths of the language. Although I had heard of Kotlin long time back from one of my friends who happens to be an Android enthusiast as well, I never took the effort to actually learn and use the language for my project, until now. Kotlin this year’s Google I/O Kotlin as a language is beautiful. It’s concise, powerful and has a very flat learning curve. Once you start getting used to this language, there’s no looking back. No disrespect for Java, but I don’t think I will use Java again for Android. Nevertheless, a tool is only as powerful as to the extent of how you use it. If you’re not going to harness the hidden gems in the language, then you might as well not use it. As I have been exploring the language, there have been some aspects of how Kotlin can speed up Android app development that caught my attention, I am going to share them with you so that you can take the wormhole and . get home from office by 6 1. Apply Android Extensions Plugin The first thing you can do is get rid of all those ugly calls, or any framework that you use for injecting your views to your Activity or Fragment or other Views. findViewById() JetBrains has bundled with its Kotlin plugin which lets you access views in your , or as if it’s just a predefined property. Confused? Just wait till you see the example. an Android extensions plugin Activity Fragment View For starters, you need to add this line to your app’s build.gradle. apply plugin: 'kotlin-android-extensions' Now your project should be ready to take advantage of plugin. Kotlin’s Android Extensions How to use it? It’s dead simple. There’s nothing to setup. No initializations to make. Just refer to your views in your Activity or Fragment or View using the IDs that you declared in the XML layout. So, let’s say you have declared your view in XML like this, <android.support.v7.widget.RecyclerView    android:id="@+id/recyclerView"    android:layout_width="match_parent"    android:layout_height="wrap_content"/> Then, you can access your RecyclerView in your Activity or Fragment or View, in this fashion, recyclerView.adapter = adapter That’s it. You don’t need to explicitly resolve the view from the XML or do any other sort of tango. No findViewById(). No ButterKnife. Your views are ready to be referred and used in your Kotlin code. This, however, will fail to work if your Kotlin class isn’t an Activity or Fragment or View because there isn’t any attached layout to the class to traverse and locate your views. But that doesn’t stop it from casting its charm. If you have an inflated View, then you can access it’s child views using this approach, view.textView.text = "Hello"view.buttonSubmit.setOnClickListener {    println("Button Clicked!")} This approach is useful in cases like accessing views inside your RecyclerView’s ViewHolder, where you need to access your views like this, class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {    fun bindData(newsModel: NewsModel) {        with(newsModel) {            itemView.heading_news.text = heading        }    }} Note that in the above code snippet, we are referencing the views present inside each row element by using their parent’s reference which is itemView. With this, you can bind pretty much every view in your project without even writing an extra line of code to do all the ceremony. findViewById() was so last year. What you need to know Android Studio does all the dirty work of importing classes seamlessly, so you never have to worry about writing out import statements yourself. However, to do that, you need to add this import statement wherever you are accessing views directly using the extension, in case the IDE fails import kotlinx.android.synthetic.main.your-layout.* And for the latter case, which is accessing views in classes that are neither an Activity nor a Fragment or a View, you need to add in a teeny tiny bit more information, import kotlinx.android.synthetic.main.your-layout.view.* That should be enough to do the job. 2. Get a Helping Hand from Anko JetBrains, the guys behind Kotlin released which is yet another tool to get the shortcut route to development completion. It includes a number of functions and approaches which will help you cut down your development time and be happy at the same time by writing compact and beautiful code for some of the very common things that we do in an Android app. a library called Anko To get started, you will need to add a dependency to your build.gradle, dependencies {    compile "org.jetbrains.anko:anko:0.10.1"} After you have performed a Gradle Sync, you should be ready to harness the power of Anko in your project. Anko comprises of several parts to cover a variety of use cases in your project, — for launching , showing , etc Anko Commons Intents Dialog ( ) — write dynamic layouts without any XML Anko Layout wiki ( ) — simplified usage of Anko SQLite wiki Android’s SQLite ( ) — helpers for Kotlin’s Anko Coroutines wiki Coroutine For the sake of brevity, I will only be talking about the usage of Anko Commons in this article. Let’s dig into it. Anko Commons offers easier and compact code to perform the most common functions in any Android app. Some of the use cases are, Launching an Intent Launching an Intent is probably the most common aspect of navigating from one screen to another in an Android app. This, however, requires a lot of ceremonies to perform especially when it comes to passing data from one activity to another. For example, if we want to launch a from the and pass some user data and make the activity a then there’s a lot to write, UserDetailsActivity MainActivity activity singleTop val userActivity = Intent(this, UserDetailsActivity::class.java)userActivity.putExtra("id", 1)userActivity.putExtra("name", "Rahul")userActivity.flags = Intent.FLAG_ACTIVITY_SINGLE_TOPstartActivity(userActivity) That’s 5 lines of code for a simple task. With Anko, you can boil that down to a one-liner, just like this, startActivity(intentFor<UserDetailsActivity>("id" to 1, "name" to "Rahul").singleTop()) It’s simple. Meaningful. Doesn’t hurt your fingers anymore. Showing a Message Two most common ways of showing a message to the user of your app are by either showing a Toast or a Dialog. Anko injects some goodness serum to both of them. Showing a is as easy as, Toast //Normal toast using a hardcoded stringtoast("Hi there!")//Normal toast using a string resourcetoast(R.string.welcome)//Long toastlongToast("Wow, such a duration") No more forgetting to call the show() function after writing a Toast message. are easy too, Dialogs alert(Appcompat, "Hi, I'm Rahul", "Do we know each other?") {    yesButton { toast("Oh…") }    noButton {}}.show() Well, that wasn’t hard to write. Note, Appcompat is specified here to tell Anko to render the AppCompat version of the dialog. If you don’t want that, you can skip that parameter. You can get a full overview of the . Anko Commons wiki over here Things to know Since Anko is a total package of several parts such as Commons, Layouts, SQLite and Coroutines, the normal package that we added increases your app size and function count by a significant amount. It’s a good practice to include only the required modules and omit the rest to keep your APK slim. You can add individual dependencies in this fashion, whichever modules you might need for your project, dependencies {    // Anko Commons    compile "org.jetbrains.anko:anko-commons:0.10.1"

    // Anko Layouts    compile "org.jetbrains.anko:anko-sdk25:0.10.1"    compile "org.jetbrains.anko:anko-appcompat-v7:0.10.1"

    // Coroutine listeners for Anko Layouts    compile "org.jetbrains.anko:anko-sdk25-coroutines:0.10.1"    compile "org.jetbrains.anko:anko-appcompat-v7-couroutines:0.10.1"

    // Anko SQLite    compile "org.jetbrains.anko:anko-sqlite:0.10.1"} 3. Write Extension Functions One of the best things about Kotlin is the ability to write extension functions and properties. Considering how screwed up some Android APIs are, this is a boon for all Android app developers. Don’t freak out if my words aren’t making any sense to you, you will get it in a minute, but before diving into how to write extension functions in Kotlin, let’s have a short intro on what they are. What are extension functions? Kotlin provides an ability to developers to add functions to a project or platform ( ) class without actually extending the class or modifying it in any conventional way. i.e., SDK Let’s clear it out with an example, suppose we have a Kotlin class like this, class StandardClass {    fun doSomething() {        //Do something here        println("Maybe print something")    }} We can now inject a function to this class which will behave like a regular function inside the class and has access to all the and present in the class without even extending it. How? This is how. properties functions fun StandardClass.doSomethingMore() {    //Do something more here    println("Maybe print something new and extra")} That’s all, and do note that this function can be defined anywhere, even as a top level function in a . The syntax or structure of defining such an extension function is as follows, regular .kt file fun receiver-class-name.function-name() {    //Body of the function goes here} How does this help? Well, all this looks very fancy, but where’s do these funky features actually come in handy when it comes to Android app development? The answer is simple. It’s your standard utilities class given a whole new dimension with the power to add missing utilities to platform APIs. Consider this case for an example. Inflating a view and adding it to a is a tedious task. For starters, you will have to get an like this, ViewGroup inflater val inflater = LayoutInflater.from(context) Then, you will have to inflate the layout and add it to the parent ViewGroup like this, inflater.inflate(R.layout.view_layout, parent, true) And you will have to do this every time you need to inflate a layout, which happens a lot of time in an Android project. So how do we make it better? We create an extension function of it. fun ViewGroup.inflate(layoutId: Int, attachToRoot: Boolean = false): View {    return LayoutInflater.from(context).inflate(layoutId, this, attachToRoot)} You can now inflate any layout by calling the inflate() function on any ViewGroup object throughout your project, like this, view.inflate(R.layout.view_layout) A thing to note in the function definition above is that we didn’t take the context as a parameter but are still able to resolve and use it. This is because since we added an extension function to the class ViewGroup, we now have access to all this properties and functions within the function block. Context being one of the defined properties in the class we can use it without any extra effort to retrieve it. Not convinced yet? Here’s another example to change your mind, fun SharedPreferences.save(function: SharedPreferences.Editor.() -> Unit) {    val editor = edit()    editor.function()    editor.apply()} What this function does is extend the class in Android to easily save data in the preferences without performing all the rituals such as getting a object from the preferences object and remembering to call or after putting all the data. SharedPreferences SharedPreferences.Editor apply() commit() Using this function is super easy, val sharedPref = PreferenceManager.getDefaultSharedPreferences(applicationContext)sharedPref.save {    putString("name", "Rahul")    putBoolean("isLoggedIn", true)} That’s was all to save some data to your app’s shared preferences. Although it might take some time initially to set up all the extension functions, once you do, your productivity will take a leap and you will be able to code much faster. Best thing? You can share your extension functions across projects and reuse them as much as you want. With extension functions, you can extend the time you have for the other things in your life. 4. Make Data Classes Work for You Kotlin introduced to simplify the creation and maintenance of model classes. Long gone are the days when you needed to write enormous boilerplate code just to create a model class. Data Classes Google tried to solve this problem with . Some others tried to solve it by creating plugins for the IDE to generate all that code for you, but having the feature built-in the language is a treat. Nothing to include. No third-party plugins to install. AutoValue What’s so special? Kotlin Data Classes generate the following things automatically for you under the hood keeping your code clean and your fingers relaxed – and functions for model comparison equals() hashCode() a formatted function to output the contents in a readable fashion toString() functions which are used to access the properties in the class componentN() function to copy properties from one object to another easily copy() All these are generated in a stealth mode which means you don’t get to see any of these functions on your Kotlin code keeping your data class clean and concise. How to declare a class as a Data Class? Just add the keyword in front of your class definition. Nothing more to do here. For example, you can define a class like this, data UserModel data class UserModel(val name: String, val age: Int, var isOnline: Boolean) Yes, you can define a whole model class in just a single line. This can’t get easier than this. The best part of this is if we want to introduce a new property to the UserModel, it would be a change of just a few characters. Let’s add a property to hold the date of birth of the user. data class UserModel(val name: String, val age: Int, var isOnline: Boolean, val dateOfBirth: Date) That’s it. I have just added a new property in the primary constructor definition. Kotlin will take care of the rest. No more adding new getter and setter or updating the toString() method. Usage in a regular Android app Almost every Android app holds data in a model. Be it user data or something else. Consider an app which connects to a backend API using and stores the response in a model class defined like this, Retrofit data class UserApiResponse(@SerializedName("user_name") var   userName: String,                           @SerializedName("age") var age: Int) It’s naive to consider that once the model is defined it won’t change. It can and will change ( ). not trying to look cool by applying Murphy’s law here Doesn’t matter if your app is local or connects to a backend API to get data, your local database schema or API response format is very much susceptible to change. What happens when it does change? You take a trip down your project structure, find the model class and make the necessary changes. Had it been the old-school way of updating your model classes, you would have to spend a good minute or two or boring task to add the field, create getters and setters, and update the toString() function as well. Thankfully, we don’t do that sort of manual labour anymore, remember? Kotlin takes care of all that for us. . Time saved Android app development is a time-consuming job. Kotlin is on a mission to make it a pleasant experience and speed up the process along the way. Make sure you use as many tricks as possible to take full advantage on this new language. See you next time, in another tutorial or general knowledge talk. Share this article if you liked it. Clap. Clap. Clap. Helps me get motivated to write more of this stuff for you.

The Wormhole Route to Android Coding Using Kotlin

some quick notes that might comes handy for beginners is a new language which at least most of Android developers heard about it or are using it instead of . Kotlin Java Out of my curiosity start learning it to know what’s attractive inside that makes some developer crazy about it! so during my learning process, I have made some notes which might look too minified but contains keywords for beginners and your later searches. This is the notes which I prefer to have at the beginning of my learning process: Variables: val immutableName: String = "Mohsen" var mutableName: String = "Mohsen"var mutableName = "Mohsen" var nullableName: String? = null val numbers = arrayListOf(1, 2, 3, 4, 5)print("Even Numbers are ${numbers.filter { i -> i % 2 == 0 }}") val countries = listOf(Pair("Iran", "Tehran"), Pair("France", "Paris"), Pair("Germany", "Berlin")) for ((country, city) in countries) {print("Country: $country - City: $city")} Functions: // fun stands for function! fun addNumbers(first: Int, second: Int): Int {return first + second}addNumbers(10, 20)addNumbers(first = 10, second = 20)addNumbers(second = 1, first = 2) // !!! // you can have multiple paramsfun addNumbers(vararg numbers: Int): Int {return numbers.sum()}addNumbers(1, 2, 3, 4, 5, 6) // default valuefun addTwoNumbers(first: Int, secound: Int = 0): Int {return first + secound}addTwoNumbers(2) Classes: // no fields in classes! only properties and functionsclass Customer(val id: Int = 0, var name: String) { // secondary constructor  
constructor(id: Int) : this(id, "")  
  
// initialize method  
init() {  
}  
  
// public by default property  
val test = 0  
  
// visible inside Customer.kt  
private fun foo() {}  
  
// property is visible everywhere  
// setter is visible only in Customer.kt  
public var bar: Int = 5  
	private set  
  
// visible inside the same module  
internal val baz = 6 } Data Classes: // mutable data classes similar to AutoValue library which provide equals, toString, copy, etc.data class Customer(val id: Int = 0, var name: String) Extension Function: fun String.convertSpacesToUnderscores(): String {return this.replace(" ", "_")} print("This is my sample String.".convertSpacesToUnderscores()) Null: val x: String = null //error!val x: String? = null // if x is not null range to 10x?.rangeTo(10) Let: var customer: Customer? = nullcustomer?.let {// it = user and not null and only read once!println(it.name)} someMethod().let { result ->//method only run once!} Any: fun getStringLen(obj: Any): Int? = if (obj is String) obj.length else null Companion: // the same as Static methods and you have to access the// method like this: Customer.Companion.what() class Customer {companion object {fun what(customer: Customer): String {return customer.id.toString() + customer.name}}} // If you want the function looks like java static methods// like this: Customer.what() have to add JvmStatic// It is useful for calling static methods from NDK librariesclass Customer {companion object {@JvmStaticfun what(customer: Customer): String {return customer.id.toString() + customer.name}}} Package function: // functions with no classes, just the same as java import staticpackage com.google.test fun packageFunction() {println("I am a package function!!")} List, ArrayList, Map: val list = listOf("a", "b")val mutableList = mutableListOf("a", "b") for (s in list) {// ...} val map = mapOf("key" to "value")val mutableMap = mutableMapOf("key" to "value") for ((key, value) in map) {// ...} Interfaces: interface TestInterface {fun run(t:Int): String fun test(){  
	// default body!  
} } Generic: class Box<T>(t: T) {// ...}Val box: Box(1) // box: Box<Int> Enums: enum class Direction(val degree: Int) {NORTH(0), EAST(90), SOUTH(180), WEST(270)} Type Casting: val y = x as Intval y = x as? Int // nullable // smart castIf (x is String)x.toUpperCase() Operator Overloading: operator fun plus(other: Point): Point = Point(x + other.x, y + other.y) Inheritance: // all classes are final by default and for inheritance should be openopen class Shape {} class Circle: Shape() {} infix: infix fun String.hello(name:String): String{return "Hello, $name. $this"} "Test" hello "test" // == "Test".hello("test") Delegates: interface Repository<T : Record> {fun getById(id: Int): Tfun getAll(): List<T>} class Controller(repository: Repository<Customer>) : Repository<Customer> by repository {fun customerList(): List<Customer> {return getAll()} fun customerById(id: Int): Customer {  
	return getById(id)  
} } var test: String by Delegates.observable("") {prop, old, new -> ("$old -> $new")} println Sealed: // sealed means there is no PageResult child more than ones that are here in this filesealed class PageResult class Success(val url: String) : PageResult()class Error(val code: Int, val message: String) : PageResult() fun getPage(url: String): PageResult {val someOperationIsSuccessfull = false if (someOperationIsSuccessfull)  
	return Success(url)  
else  
	return Error(404, "Not found") } fun callingPage() {val result = getPage("http://google.com")when (result) {is Success -> println(result.url)is Error -> println(result.message)}} Lazy: class User(firstName: String, lastName: String) {val fullName: String by lazy { "$firstName $lastName" } fun printFullName() {  
	println("User full name is: $fullName")  
} } Local return: myFunction() { numbers = 1..100numbers. ( %5==0) @forEach ( ) //Hello will be printed!} fun val forEach {if it return } println "Hello!!" Tailrec: //tailrec convert a recursive function call to a goto loop factorial(number: Int, accumulator: Int = 1): Int { (number) {0 -> accumulator -> (number - 1, accumulator * number)}} tailrec fun when return else return factorial Some unusual syntaxes for Java developers!!: // multiline string literalsprint("""1. test2. unit test3. what a test""") print("""1. test2. unit test3. what a test""".trimIndent()) print("""|1. test|2. unit test|3. what a test""".trimMargin()) fun max(a: Int, b: Int) = if (a > b) a else b // no for (int i=0;i<10;I++) loop!!!val myArray = ("A","B","C","D")for (index in 0 myArray.size){ (myArray.get(index))} arrayOf until println for ( i in 1..10 ) (myArray.get(index))} println for ( i in 100 downTo 1 step 5) (myArray.get(index))} println var i = 0while (i < 10)println (i++) // no switch case defaultwhen (i) {0 -> println("zero")1..5 -> println("number")is String -> println("$i is string")!is String -> println("is not string")else -> println("unknown!!!")} val isString = when ("Hello") {is String -> trueelse -> false} val isInRange = i in 5..9val isMember = "hello" in array // set alias while importing!Import com.google.Test as MyTest // loop operatorswhile (true){if(false) breakif(false) continueif(false) return} // labelsouter@ for (l in list) {for (m in map) {if (l == m.key) break@outer}} // Pair and Triple data typesval myPair = Pair(1, "Mohse")val myTriple = Triple(1, "A", "Mohsen")val (id, name) = myPair // measure runtime in ms!!val took = measureTimeMillis {// ...} // deprecate a method@Deprecated ("Use another method!", level = WARNING/ERROR/HIDDEN, replaceWith = ReplaceWith("newPrintFullName()", imports = "com.google.test"))fun printFullName() {// …} // rename method for Java@JvmName("methodNameInJava")fun printFullName() {// …} // inject using qualifier annotation@field:[Inject ApplicationContext]lateinit var context: Context // exclude field from serialization and gson@Transientvar id: String? = null Kotlin Android Extensions: // add plugin to build.gradleapply plugin: 'kotlin-android-extensions' import kotlinx.android.synthetic.main.<layout>.* // access views without findViewById!!myText.text = "Hello world!" I look forward for your comments, experiences with , and any unusual syntaxes which I might miss as a beginner. Share this article if you think it is useful by tapping 💚 button, and follow me for more articles . Kotlin Mohsen Mirhoseini _Senior Android Developer_mohsenoid.com Mohsen Mirhoseini

My first experiences with Kotlin

Java is a great programming language but has some known flaws, common pitfalls and not-so-great elements that have been inherited from its early days (1.0 got released in 1995). A well-respected Book on how to write good Java code, avoid common coding mistakes and deal with its weaknesses is Joshua Bloch’s “ .” It contains 78 sections, called “Items”, that give the reader valuable advice on different aspects of the language. Effective Java Creators of modern programming languages have a big advantage because they are able to analyze the weaknesses of established languages and make things better themselves. , a company that has created several very popular IDEs, decided in 2010 to create a programming language for their own development. The goal of it was to be more concise and expressive while eliminating some of the weaknesses of Java. All the previous code for their IDEs has been written in Java, so they needed a language that is highly interoperable with Java and compiles down to Java bytecode. They also wanted to make it very easy for Java developers to jump into Kotlin.With Kotlin, Jetbrains wanted to build a better Java. Jetbrains Kotlin While re-reading “Effective Java,” I found out that a lot of these Items are not necessary for Kotlin and so the idea of this blog post series about how the content of this book may have influenced Kotlin’s design was born. 1. No more builders needed with Kotlin’s default values When you have a lot of optional parameters for a constructor in Java, the code becomes verbose, hard to read and error prone. To help with that, Item 2 of Effective Java describes how to effectively use the . A lot of code is needed to construct such an object, like the nutrition facts object in the code samples below. It has two required parameters ( , ) and four optional parameters ( , , , ): Builder Pattern servingSize servings calories fat sodium carbohydrates Instantiating an object with Java looks like this: With Kotlin you don’t need to use a builder pattern at all because there is the feature of default parameters, which allow you to define default values for each optional constructor argument: Creating an object in Kotlin then looks like this: For better readability, you can also name the required parameters and : servingSize servings Like Java, the object created here is immutable. We reduced the lines of code needed from 47 in Java to 7 in Kotlin, resulting in a huge productivity boost. NOT BAD Tip: If you want to create the object in Java, you can do that of course, but you are forced to specify a value for each optional parameter. Fortunately, if you add the annotation, multiple constructors are generated. Note that if you want to use an annotation, we need the keyword too: KotlinNutrition JvmOverloads constructor 2. Easy creation of singletons Item 3 of “Effective Java” shows how to design a Java object so that it behaves as a singleton, which is an object where only a single instance can be instantiated. The code snippet below shows a “monoelvistic” universe, where only one Elvis can exist: Kotlin has the concept of that gives us the behavior of a singleton out of the box: object declarations No need to manually construct your singletons anymore! 3. equals() and hashCode() out of the box A good programming practice that has its origins in functional programming and simplifies the code is to mainly use immutable value objects. Item 15 contains the advice that “Classes should be immutable unless there’s a very good reason to make them mutable.” Immutable value objects are very tedious to create in Java, because for every object you have to override the and functions yourself. It took Joshua Bloch 18 pages to describe how to obey to the explicit general contract of these two methods in Item 8 and 9. For example, if you override you have to make sure that the of reflexivity, symmetry, transitivity, consistency and nun-nullity are all fulfilled. Sounds more like math rather than programming. equals() hashCode() equals() contracts In Kotlin, you can simply use instead, where the compiler automatically derives methods like , and many more. This is possible because the standard functionality can be mechanically derived from the properties of your object. Simply enter the keyword in front of your class and you are done. No 18 pages of description needed here. data classes equals() hashCode() data Tip: Lately, for Java became popular. This library generates immutable value classes for Java 1.6+. AutoValue 4. Properties instead of fields Item 14 recommends the use of accessor methods instead of public fields in public classes. If you do not stick to this advice you could get into trouble, because fields are then directly accessible and you lose all the benefits of encapsulation and flexibility. This means that in the future you will be unable to change the internal representation of your class without changing its public API. For instance, you cannot limit values for a field, such as the age of a person, later. That is one of the reasons why we always create those verbose default getters and setters in Java. This best practice is enforced by Kotin because it uses with auto-generated default getters and setters instead of fields. properties Syntactically you access those properties like public fields in Java with or . You can add custom getters and setters later without changing the API of the class: person.name person.age Long story short: with Kotlin’s properties, we get more concise classes with greater flexibility out of the box. 5. Override as mandatory keyword instead of optional annotation Annotations were added to Java in release 1.5. The most important one is , which marks that a method is overriding a method of a superclass. According to Item 36, this optional annotation should be constantly used to avoid nefarious bugs. The compiler then throws an error when you think you are overriding a method from a superclass but you actually do not. This works as long as you don’t forget to use the annotation. Override Override In Kotlin, is not an optional annotation but a mandatory keyword. So there is no more chance for these types of nasty bugs. The compiler will alert you about these beforehand. Kotlin sticks to . override making these kinds of things explicit That’s it This was part 1 of how “ ” may have influenced the design of Kotlin. You can to get new updates from me. Effective Java follow me on twitter See you next time! EDIT: is ! Part 2 here

How “Effective Java” may have influenced the design of Kotlin — Part 1

Photo by on Matthew Szlichta Unsplash Auto Value is a library to help you easily construct value class. It automatically generate code at build time to reduce lots of boilerplate in your source code. The Old Days Let’s start from a simple POJO to see what we can improve. public class Point { private double x;  
private double y;

public double getX() { return x; }  
public double getY() { return y; }

public void setX(double x) { x = x; }  
public void setY(double y) { y = y; }

@Override  
public int hashCode() {...}

@Override  
public boolean equals(Object other) {...}

@Override  
public String toString() {...} } What the matter of this simple code? Getter and setter seems boilerplate but we still have to add to comply with the encapsulate rule. Manually override and to distinguish different objects. hasCode() equals() Manually override for better logging purpose. toString() AutoValue is here to rescue. Get Start How Auto Value can help us? Here is the sample code after we use AutoValue. import com.google.auto.value.AutoValue; @AutoValuepublic abstract class Point { public abstract double x(); public abstract double y(); public static Point create(double x, double y) {return new AutoValue_Point(x, y);}} By add the annotation, Auto Value auto generate the class for us. We access the real class by the abstract interface . So what problem we solved? @AutoValue AutoValue_Point Point No getter anymore No setter which imply immutable in most case Hide the detail of all basic function (equals, hashCode) in the generate class p.s. One thing to notice is that we can still modify the value if it’s Array type like _List_ . What the generate class do? We can also check what do for us. AutoValue_Point final class AutoValue_Point extends Point { private final double x;private final double y; AutoValue_Point(double x,double y) {this.x = x;this.y = y;} @Overridepublic double x() {return x;} @Overridepublic double y() {return y;} @Overridepublic String toString() {return "Point{"+ "x=" + x + ", "+ "y=" + y+ "}";} @Overridepublic boolean equals(Object o) {if (o == this) {return true;}if (o instanceof Point) {Point that = (Point) o;return (Double. (this.x) == Double. (that.x()))&& (Double. (this.y) == Double. (that.y()));}return false;} doubleToLongBits doubleToLongBits doubleToLongBits doubleToLongBits @Overridepublic int hashCode() {int h = 1;h *= 1000003;h ^= (Double. (this.x) >>> 32) ^ Double. (this.x);h *= 1000003;h ^= (Double. (this.y) >>> 32) ^ Double. (this.y);return h;}} doubleToLongBits doubleToLongBits doubleToLongBits doubleToLongBits Builder Pattern What if the parameters is too many so it’s hard to read? AutoValue also support builder mode to instantiate object. import com.google.auto.value.AutoValue; @AutoValuepublic abstract class Point { public abstract double x(); public abstract double y(); public static Builder builder() {return new AutoValue_Point.Builder();} @AutoValue.Builderpublic abstract static class Builder { **public abstract Builder x(double x);  

public abstract Builder y(double y);  

public abstract Point build(); }**} The usage is simple as normal builder. Point p = Point.builder().x(100).y(100).build(); Update Value AutoValue object is immutable by its design, but the builder pattern also benefit us to clone object when we have to. Just add an abstract to indicate we have the functionality to create builder by existing value. Than we can transform the builder back to object after we update value or at anytime. toBuilder @AutoValuepublic abstract class Point { public abstract double x(); public abstract double y(); public static Builder builder() {return new AutoValue_Point.Builder();} public abstract Builder toBuilder(); public Point withX(double x) {return toBuilder().x(x).build();} @AutoValue.Builderpublic abstract static class Builder {public abstract Builder x(double x); public abstract Builder y(double y);  

public abstract Point build(); }} Reference _auto - A collection of source code generators for Java._github.com google/auto

Altova News on
HackerNoon and Around the Web

altova.com

26 employees

Since 1992

124054 at Alexa

Altova Story Mentions

Articles Around the Web

Read More Tech Stories Related to #Altova

Altova News on HackerNoon and Around the Web