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

altova

In this article, I will delve into whether artificial intelligence (AI), particularly the emergence of tools like generative AI (GenAI), will replace classical software outsourcing as we know it.

AI vs software outsourcing: An opportunity or a threat?

We've tested more than 100 anti-malware apps to help you find the top malware protection and removal software for all your devices. When the IBM PC was new, I served as the president of the San ...

The Best Malware Removal and Protection Software for 2023

The warning was issued by GitHub after the software development platform recently disclosed the existence of a memory corruption flaw in the libcue library which parses cue sheets. It’s being ...

This software relic from the CD era could put your entire PC at risk

To specifically create a 32-bit environment in the folder “~/.wine32” for older Windows software ... as a whole or transferred to another Linux computer running Wine, because the Wine prefix ...

How to use Windows software in Linux

Commissions do not affect our editors' opinions or evaluations. When taxes are due, choosing a good online tax software can ease your burden. We tested and reviewed five of the top online tax ...

Best Online Tax Software Of October 2023

The release includes Altova MissionKit desktop developer tools and server software products. In addition, version 2020 focuses on JSON with a new JSON Grid View designed to speed up JSON editing ...

SD Times news digest: Altova 2020, TPG completes acquisition of CollabNet VersionOne, CodeStream 4.0

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

But as often happens, it’s having a few growing pains with some hardware and software configurations, particularly machines running AMD. According to users across several social networks ...

Windows 11’s big update is breaking AMD Radeon’s software

Our B.A. in Computer Science: Software Project Management addresses a growing need in industry to manage the finances and personnel of complex software development projects. Computer Science majors who graduate and start out as programmers in larger ...

Software Project Management Major

Database pricing models are hard. As a developer looking for a managed database, one of the most annoying (and yet crucial) aspects of the search process involves evaluating not only the upfront price of the solution for your database size but also how the pricing works and how well it will scale. On top of the nuances when evaluating database pricing (e.g., “How much does the bill increase as my data grows?”, “Am I being charged per writes or reads?”, and “Do I have to pay more per backups?”), developers tend to overlook one aspect: the way a database's pricing model is structured will influence how you manage your data and assess your Postgres database size. Different pricing models require different approaches to running PostgreSQL. For example, if you’re locked into a large disk, you might not prioritize reducing your database size. If you’re charged per data read, you might think twice about running certain queries, and if you’re charged per data ingress, you may be cautious about the frequency and volume of newly ingested data. Each pricing element subtly influences the strategies and behaviors you’ll end up adopting, pushing you toward a particular way of managing and interacting with your database to ensure both cost-efficiency and optimal performance. , with great customer feedback. In this blog post, we’ll explore the operational advantages we’ve observed from our customers since transitioning to this model, together with tactics on how to optimally manage your PostgreSQL storage in a usage-based model. At Timescale, we transitioned to a usage-based storage model a few months ago Usage-based storage models are becoming increasingly popular in the database world—who wants to pay for disk space they’re not using? Still, a usage-based model doesn’t come without consequences, and you need to consider some best practices to navigate it effectively. Quick Recap on PostgreSQL Storage Models To lay out a common ground for our discussion on managing your database size in a usage-based model, let’s start by quickly covering how pricing works in our PostgreSQL platform ( ) and how it compares to other managed PostgreSQL products, like Amazon RDS for PostgreSQL and Amazon Aurora. Timescale Starting yesterday (💥), we offer two types of database services in the Timescale platform: , where developers can create PostgreSQL databases with dynamic compute to save money without sacrificing performance. Dynamic PostgreSQL services Time Series services, where developers can create PostgreSQL databases boosted with extra performance and scalability via hypertables, columnar compression, , and tiered storage. continuous aggregates Let’s focus on how we price storage on our platform. Both these services come with a usage-based model for storage, which means the following: Developers are charged for the volume they use, without small print—no minimum database size, no minimum scaling steps. If, by the end of the month, you’ve used 128 GB, that’s what you’ll be billed for. You can start at 1 GB and grow to TBs. There are no charges based on data written, data transfers, or queries run. No need to allocate storage when creating a database or scaling. No need to manually downsize disks. To bring this home, let’s lay out the differences between this model, Amazon RDS PostgreSQL, and Amazon Aurora: In summary, here are the three main takeaways from our comparison: Both Timescale and Aurora charge for your actual database size. In contrast, RDS PostgreSQL charges for provisioned storage. You can’t downsize volumes in RDS. Timescale does not charge for data written, data transfers, or query operations. Both RDS and Aurora charge per data transfer, extra backup storage, and you might incur some extra I/O charges, depending on which type of storage you’re picking. Timescale has no minimum scaling steps, whereas Aurora scales in 10 GB increments after starting with 10 GB. As you can see, Timescale’s model is closer to , with the difference that Timescale lacks scaling steps and extra charges for things like data transfer. In contrast, RDS is a good representation of the allocation-based model, even if traditionally found in database vendors operating on this model. Aurora I/O-Optimized RDS lacks the “storage tiers” How Usage-Based Pricing Improves PostgreSQL Storage Management As we previously introduced, different pricing models imply different database experiences. When we transitioned from an allocation-based to a usage-based model, our customers told us they saw immediate improvements in three operational areas: They didn’t need to provision storage upfront when starting a database, which led to fewer overprovisioning mistakes and, therefore, lower storage bills. They didn’t have to think about storage while scaling up. They could downscale—e.g., if they deleted data, they stopped paying for it. Usage-based models eliminate the problem of storage overprovisioning In traditional allocation-based models, developers often find themselves predicting their storage needs, which, very often, leads to storage overprovisioning. We observed this across our fleet when Timescale operated on a usage-based model: the majority of our customers were not using their full disk capacity, which means they were essentially paying for storage space they weren't yet using. Usage-based models eliminate this guessing game (and the consequences of wrong guesswork). You don’t need to think about storage while scaling up “Timescale's usage-based storage means I don't have to think about disk size anymore. Our storage cost is down 30 %, and I didn't have to do anything!" Adam McCrea, (Timescale customer) Judoscale In usage-based models, the storage scales seamlessly as your database grows. A main source of stress in traditional allocation-based models is the danger of running out of disk space, which can lead to numerous problems ranging from application downtime and lost transactions to data corruption in the worst-case scenarios. With usage-based models, developers no longer have to vigilantly monitor their storage to avoid hitting a storage wall. At the same time, they don’t have to worry about heavy autoscaling steps or tier jumps. You can downscale (stop paying for data you deleted) Last but not least, usage-based models allow you to “downscale.” If you delete data (or manage to reduce your database size considerably), you start paying less per storage, which sounds only fair. As we’ll see in the next section, Timescale has a few features to help customers reduce their PostgreSQL database size. Adopting a usage-based model allowed our customers to immediately realize savings when reducing disk usage, which incentivized them to keep their database lean. How to Effectively Navigate a Usage-Based Model: Tips to Reduce Your Postgres Database Size The benefits we just mentioned improve the developer experience of working with storage significantly, which is why usage-based models are becoming very popular. But usage-based pricing comes with an obvious (yet profound) consequence: it forces developers to adopt good data practices to reduce their PostgreSQL database size as much as possible. When you know that your storage costs are directly linked to the disk size you’re actually using, there’s a newfound incentive to be more judicious with data storage. If you’re operating in a usage-based model for storage, it becomes your responsibility to ensure you’re storing data efficiently. In a way, this can be considered a “drawback” of usage-based models, and it requires some work—but this is actually a blessing in disguise. In traditional allocation-based models, data hygiene can be somewhat overlooked because the costs are fixed: if you’re locked into a 500 GB disk in RDS, and your database is 200 GB, you don’t seem to have a big incentive to make storage usage efficient. But here’s the thing: good data practices are not just about saving money. To scale a PostgreSQL database, it is essential to keep it optimized. By adopting good PostgreSQL data management practices, you will not only see better performance but your life as a database administrator will get much easier. With this in mind, let’s run through some practices that will help you navigate a usage-based model for storage as effectively as possible, reducing your PostgreSQL database size in a systematic way. In the particular case of Timescale, we have some particularly helpful features, which we’ll cover as well. Reduce bloat in your PostgreSQL database A first must-do in a usage-based model is to pay attention to the specifics of how PostgreSQL storage works, i.e., you must reduce bloat on a regular basis. This will help you not only with your database size but also with your I/O requirements. We’ll point you toward some basics in this section, , and we’ve also written . but this HN thread has some great advice a blog post on table bloat in PostgreSQL A proactive approach to optimizing PostgreSQL storage begins with keeping a close eye on dead tuples. Dead tuples, if left unchecked, can accumulate and lead to unnecessary storage overheads. The extension can be a great ally to understanding how tables manage these tuples. Monitor dead tuples. pgstattuple() To effectively combat table bloat, you might want to configure autovacuum to run more frequently. Rather than globally adjusting autovacuum settings in postgresql.conf, it's more precise to fine-tune these settings on a per-table basis. This caters to the fact that different tables can have varying tendencies for accumulating dead tuples. It's also crucial to monitor long-running transactions that might hinder autovacuum operations. Vacuum frequently. While autovacuum and vacuum address dead tuples, reclaiming unused pages demands a different approach. Although VACUUM FULL can be utilized for this purpose, it has the inherent limitation of locking the entire table. can help you with this. Reclaim unused pages. Pg_repack Do some PostgreSQL fine-tuning Systematically reducing your PostgreSQL database size is closely related to being able to scale your PostgreSQL database effectively, i.e., keeping things fast and agile while you’re adding more and more data. Keeping an eye on (and perhaps adjusting) some key PostgreSQL parameters can help. . Here are some aspects you need to consider: This article reviews the most important performance parameters : controls the memory used for PostgreSQL’s page cache, and it’s typically set to 25 % of the system’s total RAM. shared_buffers : it sets the memory allocated per operation within a query. In Timescale, the recommended setting is . work_mem (25 % of RAM) / max_connections : it sets the max number of concurrent connections allowed to the database. Connection poolers can help manage many short-lived connections. max_connections : it determines the max number of worker processes PostgreSQL can initiate. If using Timescale, the formula to set this parameter is: . max_worker_processes max_worker_processes = 3 + timescaledb.max_background_workers + max_parallel_workers : it specifies the max number of workers supporting parallel queries. The default is to set this equal to the number of available CPUs. max_parallel_workers : it determines the max number of concurrent autovacuum processes. In Timescale, it is set to 10 by default. autovacuum_max_workers Practice indexing hygiene Regularly optimizing indexes will help keep your PostgreSQL efficient, especially as the database scales. While indexes can help you improve query performance when used wisely, excessive indexes can create issues in large PostgreSQL deployments. The most obvious consequence of excessive indexing is increased storage consumption, as every index necessitates separate storage, which grows proportionally with the size of the tables. This overhead can become more significant when tables are partitioned, like in Timescale’s hypertables. Unnecessary indexes can also be counterproductive in improving your write operations, as each new data entry or modification implies concurrent index updates, leading to more I/O operations and potential table bloat. Monitoring your indexes will help you identify which ones are no longer being used, keeping things lean. One way to do this is by using : pg_stat_user_indexes -- Retrieve indexes that might not be used or are infrequently used
SELECT
    schemaname,
    relname AS table_name,
    indexrelname AS index_name,
    idx_scan AS times_used
FROM
    pg_stat_user_indexes
WHERE
    idx_scan = 0
    OR idx_scan < some_low_threshold -- replace 'some_low_threshold' with a value that makes sense for your context
ORDER BY
    idx_scan ASC, schemaname, relname; If an index has a value of 0 in the idx_scan column, it means it hasn't been used since the last time the statistics were reset, meaning that it could be a candidate for optimization. By setting a low threshold for , you can also identify infrequently used indexes. idx_scan Shrink your large tables via Timescale compression One of Timescale's standout features is its native support for columnar compression, which can drastically reduce the disk space used by large tables without compromising query performance. Compression improves the performance of many queries. Timescale's compression works by converting regular row-based data into a more compact columnar format. This process is particularly effective for time-series data, where many columns may contain repetitive values; we can achieve impressive compression rates (+90 %) by applying different compression algorithms depending on each data type. This means that your large tables can be shrunk up to 10x. In Timescale, compression is enabled on a table-by-table basis via a time-based compression policy. For example, this code enables compression in a particular hypertable and automatically compresses data older than two weeks: -- Enable compression on the hypertable
ALTER TABLE your_hypertable SET (
  timescaledb.compress,
  timescaledb.compress_segmentby = 'some_column'
);
-- Set a compression policy to compress data older than two weeks
SELECT add_compression_policy('your_hypertable', INTERVAL '2 weeks'); To learn more about compression, . check out our documentation Set up a data management strategy: Move older data to cheaper storage, delete the data you no longer need The previous tactics are very helpful in reducing your database size, but there is another avenue you can leverage in Timescale to scale your storage effectively: tiered storage. By creating a simple tiering policy, you can move older, less-accessed data to a bottomless object storage layer: -- This policy moves all data older than one month to object storage 
SELECT add_tiering_policy('example', INTERVAL '1 month); This object store has the following characteristics: It comes with a lower price point than our high-performance storage, allowing you to store many TBs of data for much less. It is infinite, meaning you can store as much data as you’d like. This tiered storage architecture is ingrained in Timescale’s backend. The object storage is not a “bucket” detached from your database—instead, it’s an integral part of it. Queries will transparently access both storage layers without any action needed from you—you can just keep using standard SQL over the same schema. Once your tiering policy is set, there’s nothing else to consider! We recommend moving data to the low-cost storage layer once it’s not being frequently accessed by your application since there’s a performance cost (the object store is not as fast as our regular storage). But you can keep running ad-hoc queries over this data comfortably (e.g., queries that are not critical for the user experience of your customers and for which top performance is not essential). Editor’s note: We’ll share exciting news on tiered storage soon. 🎉 Stay tuned! On top of offering this low-cost storage layer, Timescale makes it easy to set up data retention policies to delete data you no longer need: -- Set a data retention policy to drop data older than 10 months
SELECT add_retention_policy('your_hypertable', INTERVAL '10 months'); You can combine data retention policies like the one above with continuous aggregates to effectively downsample your dataset—e.g., reducing granularity from one second to one minute, deleting the one-second values but keeping the one-minute aggregates. . Read this blog post to see an example of how to do this and proactively manage long-term data Usage-Based Models and the Data Management Paradigm While usage-based models may seem nothing but a pricing change on the surface, they bring about a paradigm shift in how developers think about their database size and how they perceive and handle data. Usage-based models promote a culture of continuous improvement, where the focus shifts from mere storage management to database health and efficiency. This requires some discipline at first, but once your mindset shifts and you learn some techniques, you’ll be in the best place to scale your PostgreSQL database efficiently and effectively. Timescale has valuable tools to help you systematically reduce your PostgreSQL database size, like compression, tiered storage, and data retention policies. This allows you to effectively scale your PostgreSQL databases in a usage-based model. . To experience it yourself, sign up for Timescale—you can use it for free for the first 30 days - Written by . Carlota Sota Also published here.

Strategies for Database Size Reduction in PostgreSQL: A Usage-Based Approach

PostgreSQL-এ ডাটাবেসের আকার হ্রাসের কৌশল: একটি ব্যবহার-ভিত্তিক পদ্ধতি

Strategien zur Reduzierung der Datenbankgröße in PostgreSQL: Ein nutzungsbasierter Ansatz

Estrategias para reducir el tamaño de la base de datos en PostgreSQL: un enfoque basado en el uso

Stratégies de réduction de la taille des bases de données dans PostgreSQL : une approche basée sur l'utilisation

PostgreSQL में डेटाबेस आकार में कमी के लिए रणनीतियाँ: एक उपयोग-आधारित दृष्टिकोण

PostgreSQL でのデータベース サイズ削減の戦略: 使用量ベースのアプローチ

PostgreSQL의 데이터베이스 크기 감소 전략: 사용량 기반 접근 방식

Estratégias para redução do tamanho do banco de dados no PostgreSQL: uma abordagem baseada no uso

Стратегии уменьшения размера базы данных в PostgreSQL: подход, основанный на использовании

PostgreSQL'de Veritabanı Boyutunu Küçültme Stratejileri: Kullanıma Dayalı Bir Yaklaşım

Các chiến lược giảm kích thước cơ sở dữ liệu trong PostgreSQL: Cách tiếp cận dựa trên việc sử dụng

PostgreSQL 中数据库大小减小的策略：基于使用的方法

A Journey to the Center of the Earth by Jules Verne, is part of the HackerNoon Books Series. You can jump to any chapter in this book . FIRST LESSONS IN CLIMBING here CHAPTER V - FIRST LESSONS IN CLIMBING At Altona, a suburb of Hamburg, is the Chief Station of the Kiel railway, which was to take us to the shores of the Belt. In twenty minutes from the moment of our departure we were in Holstein, and our carriage entered the station. Our heavy luggage was taken out, weighed, labeled, and placed in a huge van. We then took our tickets, and exactly at seven o'clock were seated opposite each other in a firstclass railway carriage. My uncle said nothing. He was too busy examining his papers, among which of course was the famous parchment, and some letters of introduction from the Danish consul which were to pave the way to an introduction to the Governor of Iceland. My only amusement was looking out of the window. But as we passed through a flat though fertile country, this occupation was slightly monotonous. In three hours we reached Kiel, and our baggage was at once transferred to the steamer. We had now a day before us, a delay of about ten hours. Which fact put my uncle in a towering passion. We had nothing to do but to walk about the pretty town and bay. At length, however, we went on board, and at half past ten were steaming down the Great Belt. It was a dark night, with a strong breeze and a rough sea, nothing being visible but the occasional fires on shore, with here and there a lighthouse. At seven in the morning we left Korsor, a little town on the western side of Seeland. Here we took another railway, which in three hours brought us to the capital, Copenhagen, where, scarcely taking time for refreshment, my uncle hurried out to present one of his letters of introduction. It was to the director of the Museum of Antiquities, who, having been informed that we were tourists bound for Iceland, did all he could to assist us. One wretched hope sustained me now. Perhaps no vessel was bound for such distant parts. Alas! a little Danish schooner, the , was to sail on the second of June for Reykjavik. The captain, M. Bjarne, was on board, and was rather surprised at the energy and cordiality with which his future passenger shook him by the hand. To him a voyage to Iceland was merely a matter of course. My uncle, on the other hand, considered the event of sublime importance. The honest sailor took advantage of the Professor's enthusiasm to double the fare. Valkyrie "On Tuesday morning at seven o'clock be on board," said M. Bjarne, handing us our receipts. "Excellent! Capital! Glorious!" remarked my uncle as we sat down to a late breakfast; "refresh yourself, my boy, and we will take a run through the town." Our meal concluded, we went to the Kongens-Nye-Torw; to the king's magnificent palace; to the beautiful bridge over the canal near the Museum; to the immense cenotaph of Thorwaldsen with its hideous naval groups; to the castle of Rosenberg; and to all the other lions of the place-none of which my uncle even saw, so absorbed was he in his anticipated triumphs. But one thing struck his fancy, and that was a certain singular steeple situated on the Island of Amak, which is the southeast quarter of the city of Copenhagen. My uncle at once ordered me to turn my steps that way, and accordingly we went on board the steam ferry boat which does duty on the canal, and very soon reached the noted dockyard quay. In the first instance we crossed some narrow streets, where we met numerous groups of galley slaves, with particolored trousers, grey and yellow, working under the orders and the sticks of severe taskmasters, and finally reached the Vor-Frelser's-Kirk. This church exhibited nothing remarkable in itself; in fact, the worthy Professor had only been attracted to it by one circumstance, which was, that its rather elevated steeple started from a circular platform, after which there was an exterior staircase, which wound round to the very summit. "Let us ascend," said my uncle. "But I never could climb church towers," I cried, "I am subject to dizziness in my head." "The very reason why you should go up. I want to cure you of a bad habit." "But, my good sir—" "I tell you to come. What is the use of wasting so much valuable time?" It was impossible to dispute the dictatorial commands of my uncle. I yielded with a groan. On payment of a fee, a verger gave us the key. He, for one, was not partial to the ascent. My uncle at once showed me the way, running up the steps like a schoolboy. I followed as well as I could, though no sooner was I outside the tower, than my head began to swim. There was nothing of the eagle about me. The earth was enough for me, and no ambitious desire to soar ever entered my mind. Still things did not go badly until I had ascended 150 steps, and was near the platform, when I began to feel the rush of cold air. I could scarcely stand, when clutching the railings, I looked upwards. The railing was frail enough, but nothing to those which skirted the terrible winding staircase, that appeared, from where I stood, to ascend to the skies. "Now then, Henry." "I can't do it!" I cried, in accents of despair. "Are you, after all, a coward, sir?" said my uncle in a pitiless tone. "Go up, I say!" To this there was no reply possible. And yet the keen air acted violently on my nervous system; sky, earth, all seemed to swim round, while the steeple rocked like a ship. My legs gave way like those of a drunken man. I crawled upon my hands and knees; I hauled myself up slowly, crawling like a snake. Presently I closed my eyes, and allowed myself to be dragged upwards. "Look around you," said my uncle in a stern voice, "heaven knows what profound abysses you may have to look down. This is excellent practice." Slowly, and shivering all the while with cold, I opened my eyes. What then did I see? My first glance was upwards at the cold fleecy clouds, which as by some optical delusion appeared to stand still, while the steeple, the weathercock, and our two selves were carried swiftly along. Far away on one side could be seen the grassy plain, while on the other lay the sea bathed in translucent light. The Sund, or Sound as we call it, could be discovered beyond the point of Elsinore, crowded with white sails, which, at that distance looked like the wings of seagulls; while to the east could be made out the far-off coast of Sweden. The whole appeared a magic panorama. But faint and bewildered as I was, there was no remedy for it. Rise and stand up I must. Despite my protestations my first lesson lasted quite an hour. When, nearly two hours later, I reached the bosom of mother earth, I was like a rheumatic old man bent double with pain. "Enough for one day," said my uncle, rubbing his hands, "we will begin again tomorrow." There was no remedy. My lessons lasted five days, and at the end of that period, I ascended blithely enough, and found myself able to look down into the depths below without even winking, and with some degree of pleasure. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jules Verne (2006). A Journey to the Center of the Earth. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/files/18857/18857-h/18857-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

FIRST LESSONS IN CLIMBING

The inspiration to delve into this topic came from a YouTube video titled “The Metaverse: Seven Metaverse Companies That Are Making It a Reality.” This seven-minute-long video explains how seven famous tech companies are shaping the metaverse industry. Chances are that 2023 might just be another year for the industry to grow bigger. metaverse According to Precedence Research, a consulting firm that provides industry insights and market analysis, the is estimated to reach $1.3 trillion by 2030 based on four market drivers which include, increasing investment in the metaverse, rising demands in the media and entertainment industry, increasing uses of metaverse platforms, and rising popularity of interaction models and digital identities. metaverse market size https://youtu.be/SQSWn1CMrv8?embedable=true In this article, we explore some of the most popular metaverse companies in the world and their niches bearing in mind that the number of companies and brands entering the metaverse space is fast growing. Decentraland Decentraland is a popular metaverse platform running on the Ethereum blockchain technology. It was founded by Ari Meilich and Esteban Ordano in 2015, and its niche is virtual land ownership and development. Decentraland users are incentivized to buy, sell, and trade virtual land using its native ERC-20 token, MANA. Above all, there is the freedom to create their own unique experiences within the virtual world, and it grants users ownership and control over their virtual assets. Sandbox Sandbox is a popular gaming metaverse platform where users can create, share, and monetize their virtual assets. It is a user-generated virtual world that provides a variety of tools and assets for developing games and building social spaces. Sandbox has a thriving community for creators and players to collaborate on gaming projects and share ideas. The Sandbox was founded in 2012 by Sebastien Borget, Arthur Madrid, and Nicolas Pouard. It started as a mobile game studio known as Pixowl before gravitating toward blockchain technology. Roblox Roblox has millions of users as a leading gaming platform in the virtual realm. It is known for its vibrant environment and a wide range of game options and virtual worlds where users can create virtual immersive experiences and play games. It also has virtual hangouts where millions of users can connect with friends and join virtual events. Users can also learn coding through the Roblox Studio, and it is tailored to captivate and serve metaverse users of all ages. Roblox was founded in 2004 by David Baszucki and Erik Cassel as Dynablocks, a physics-based educational tool. It later had a change of name and transitioned to a user-generated content platform and virtual gaming community. Voxels Metaverse Voxels Metaverse, formerly known as Cryptovoxels, was founded by Ben Nolan in 2018. It is an Ethereum-based metaverse platform that is a bit similar to Decentraland. For example, Voxels Metaverse and Decentraland run on the Ethereum blockchain and allow users to earn from playing games. In the Voxels Metaverse environment, there are endless possibilities for creativity and exploration. Users can build, explore, and trade their voxel-based virtual creations. Vowels Metaverse is built around the concepts of decentralization and blockchain ownership, which allows users to have full control over their virtual land and assets. Spatial Spatial is an immersive collaboration platform that was designed to host remote meetings and events in its virtual environment. Its market niche is metaverse-based virtual conferencing which allows users to link up, interact, and collaborate, regardless of physical distance. Spatial combines VR and AR technologies to deliver remote collaboration and its unique settings  have continued to attract various industries that are seeking to incorporate the metaverse technology. One of the immersive qualities of Spatial is that it uses AI to generate data from images of its users and physical environments to create accurate 3D models. Spatial was founded in 2016 by Anand Agarawala and Jinha Lee who were inspired to create immersive augmented and virtual reality experiences. ALTAVA Group ALTAVA Group is a luxury Metaverse platform that offers a unique opportunity for leading brands to connect their in-person and digital experiences through the power of blockchain technology. ALTAVA's most notable NFT is the BAGC Collection, a golf-themed derivative of the Bored Ape Yacht Club (BAYC) licensed from Elite Apes, The Sandbox, and Animoca Brands. ALTAVA has blue-chip equity and token investors such as Hyundai, LG, Spartan, and Animoca Brands. It also has a Second Skin NFT Collection that links directly to WOY, the company's own Metaverse, available on the App Store and Play Store. High Fidelity High Fidelity was in 2013 founded by Philip Rosedale with the aim of creating a next-generation virtual reality platform. High Fidelity is a blockchain-based metaverse platform that focuses on social interaction, events, and commerce in virtual reality. It provides the tools for users to create and customize their virtual avatars, attend virtual meetings, and engage in virtual trade. Its aim is to promote social connections and meaningful experiences within the virtual realm. Upland Upland is a metaverse company that combines virtual property trading with real-world locations. It was founded in 2018 by Dirk Lueth and Idan Zuckerman. Upland allows its users to buy, sell, and trade virtual assets that mirror real-world addresses, enabling them to own and manage virtual assets tied to actual geographic locations. It offers a unique combination of virtual and real-world experiences for users to explore and engage with. The MetaVRse The MetaVRse is a well-known development studio in augmented reality and virtual reality experiences. It was founded by Alan Smithson in 2016 as a platform for immersive content and applications that leverage AR, MR, and VR technologies for the needs of various industries, including entertainment, marketing and training, retail, real estate, and health care. NeosVR NeosVR is a user-generated virtual reality platform founded by Karel Hulec in 2014. It provides a platform for creation, collaboration, and exploration. NeosVR users can build their own virtual environments, interact with others, and develop interactive experiences using a wide range of tools and assets. Its focus is primarily on its community of creators who push the boundaries of virtual reality experience. Conclusion The metaverse is a rapidly evolving field with a vast potential to shape the future of virtual experiences. The rapid growth of the metaverse industry is spurred by the growing number of  companies and brands entering this space. As a result of this, it has experienced a boost in innovation, and creativity, and it has created endless possibilities to explore the virtual worlds. Each metaverse platform has its unique features, communities, and opportunities for users to explore. In gaming, socializing, creating, or conducting business, the metaverse is capable of creating a new frontier for human interaction and experience, and with the continued advancements and improvements, it is destined to transform the way we connect, collaborate, and experience the virtual world.

Exploring Popular Metaverse Platforms And Their Niches

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

Stories, News & Mentions about ALTOVA

Altova’s Stories on HackerNoon

Altova's News & Mentions