Archive for the ‘en-US’ Category
[DotSecurity2017] Names and Security
Amid the internet’s inexorable expansion, where identities intermingle in a vast virtual bazaar, nomenclature emerges not merely as label but as linchpin of legitimacy and liability. Paul Mockapetris, the visionary architect of the Domain Name System (DNS), unraveled this nexus at dotSecurity 2017, positing names as the nascent nucleus of network nativity—superseding addresses in an era of fluid federation. From USC’s Information Sciences Institute to ThreatSTOP’s chief scientific stewardship, Paul’s provenance—DNS’s 1983 inception—imbues his insights with unparalleled pedigree, transforming arcane protocols into actionable armaments against cyber malfeasance.
Paul’s preamble pulsed with principles: network’s nectar in connectivity’s cornucopia, generative genius in repurposing relics—DNS’s domain, a namespace nexus granting granular governance amid global glue. Scaling’s saga: hierarchical hierarchies, root’s realm radiating to TLDs’ tributaries—federation’s finesse in delegation’s dance, authorities autonomous yet amalgamated. Security’s shadow: names’ nobility invites nefariousness—phishing’s phalanx, malware’s masquerade, DDoS’s deluge. Paul parsed perils: DNS amplification’s acoustic assault (amplifiers unwitting, queries quartered to quintupled payloads), cache’s corruption (poison’s payload, TTL’s tyranny), BGP’s brittleness (routes rerouted, traffic tunneled).
Countermeasures crystallized: DNSSEC’s digital deeds—RRSIG’s ratification, DS’s delegation—yet adoption’s anemia (1% in 2017) attenuates. Paul’s panacea: name-based bulwarks—reputation’s rubric (Sender Policy Framework’s sender scrutiny, Domain-based Message Authentication’s dominion), filtering’s firewall (blacklists’ ban, whitelists’ welcome). ThreatSTOP’s tapestry: DNS as sentinel, policies personalized—user’s umbrage over ISP’s imposition, EFF’s equivocation on censorship’s cusp. Kill chain’s kink: download’s dam, C2’s choke—malware muted mid-metamorphosis.
Paul’s prognosis: addresses’ atrophy, names’ ascendancy—chunked content’s cryptographic christening, bounties’ bounty for blemished bits. This nomenclature renaissance: security’s scaffold, internet’s integrity incarnate.
Nomenclature’s Nobility and Perils’ Palette
Paul proclaimed principles: network’s nexus, generative’s grace—DNS’s delegation, scaling’s symphony. Perils’ procession: amplification’s aria, cache’s contagion—BGP’s betrayal.
DNSSEC’s Deeds and Name’s Nativity
Signatures’ surety, adoption’s ache—reputation’s regime (SPF’s sieve, DMARC’s dominion). ThreatSTOP’s theorem: policies’ personalization, kill chain’s curtailment.
Bounties’ Beacon and Futures’ Forge
Addresses’ eclipse, chunks’ christening—bounties’ bite for blemish. Paul’s prophecy: names’ nativity, security’s scaffold.
Links:
[KotlinConf2017] A View State Machine for Network Calls on Android
Lecturer
Amanda Hill is an experienced Android developer currently working as a consultant at thoughtbot, a firm specializing in mobile and web application development. A graduate of Cornell University, Amanda previously served as the lead Android developer at Venmo, where she honed her expertise in building robust mobile applications. Based in San Francisco, she brings a practical perspective to Android development, with a passion for tackling challenges posed by evolving design specifications and enhancing user interfaces through innovative solutions.
Abstract
Managing network calls in Android applications requires robust solutions to handle dynamic UI changes. This article analyzes Amanda Hill’s presentation at KotlinConf 2017, which introduces a view state machine using Kotlin’s sealed classes to streamline network request handling. It explores the context of Android development challenges, the methodology of implementing a state machine, its practical applications, and the implications for creating adaptable, maintainable UI code. Amanda’s approach leverages Kotlin’s type-safe features to address the complexities of ever-changing design specifications, offering a reusable framework for Android developers.
Context of Android Network Challenges
At KotlinConf 2017, Amanda Hill addressed a common pain point in Android development: managing network calls amidst frequently changing UI requirements. As an Android developer at thoughtbot, Amanda drew on her experience at Venmo to highlight the frustrations caused by evolving design specs, which often disrupt UI logic tied to network operations. Traditional approaches to network calls, such as direct API integrations or ad-hoc state management, often lead to fragile code that struggles to adapt to UI changes, resulting in maintenance overhead and potential bugs.
Kotlin’s adoption in Android development, particularly after Google’s 2017 endorsement, provided an opportunity to leverage its type-safe features to address these challenges. Amanda’s presentation focused on creating a view state machine using Kotlin’s sealed classes, a feature that restricts class hierarchies to a defined set of states. This approach aimed to encapsulate UI states related to network calls, making Android applications more resilient to design changes and improving code clarity for developers working on dynamic, data-driven interfaces.
Methodology of the View State Machine
Amanda’s methodology centered on using Kotlin’s sealed classes to define a finite set of UI states for network calls, such as Loading, Success, and Error. Sealed classes ensure type safety by restricting possible states, allowing the compiler to enforce exhaustive handling of all scenarios. Amanda proposed a view model interface to standardize state interactions, with methods like getTitle and getPicture to format data for display. This interface serves as a contract, enabling different view models (e.g., for ice-cream cones) to implement specific formatting logic while adhering to a common structure.
In her live demo, Amanda illustrated building an Android app that uses the view state machine to manage network requests. The state machine processes API responses, mapping raw data (e.g., a calorie count of 120) into formatted outputs (e.g., “120 Calories”). By isolating formatting logic in the view model, independent of Android’s activity or fragment lifecycles, the approach ensures testability and reusability. Amanda emphasized flexibility, encouraging developers to customize the state machine for specific use cases, balancing genericity with adaptability to meet diverse application needs.
Practical Applications and Testability
The view state machine’s practical applications lie in its ability to simplify UI updates in response to network call outcomes. Amanda demonstrated how the state machine handles transitions between states, ensuring that UI components reflect the current state (e.g., displaying a loading spinner or an error message). By decoupling state logic from Android’s lifecycle methods, the approach reduces dependencies on activities or fragments, making the code more modular and easier to maintain. This modularity is particularly valuable in dynamic applications where UI requirements evolve frequently.
Testability is a key strength of Amanda’s approach. The view model’s independence from lifecycle components allows unit tests to verify formatting logic without involving Android’s runtime environment. For example, tests can assert that a view model correctly formats a calorie count, ensuring reliability across UI changes. Amanda’s focus on simplicity ensures that developers can implement the state machine without extensive refactoring, making it accessible for teams adopting Kotlin in Android projects.
Implications for Android Development
Amanda’s view state machine has significant implications for Android development, particularly in enhancing code maintainability and adaptability. By leveraging Kotlin’s sealed classes, developers can create robust, type-safe state management systems that reduce errors caused by unhandled states. The approach aligns with Kotlin’s emphasis on conciseness and safety, enabling developers to handle complex network interactions with minimal boilerplate. This is particularly valuable in fast-paced development environments where UI requirements change frequently, such as in fintech or e-commerce apps.
For the broader Android ecosystem, the state machine promotes best practices in separating concerns, encouraging developers to isolate business logic from UI rendering. Its testability supports agile development workflows, where rapid iterations and reliable testing are critical. Amanda’s encouragement to customize the state machine fosters a flexible approach, empowering developers to tailor solutions to specific project needs while leveraging Kotlin’s strengths. As Kotlin continues to dominate Android development, such innovations enhance its appeal for building scalable, user-friendly applications.
Conclusion
Amanda Hill’s presentation at KotlinConf 2017 introduced a powerful approach to managing network calls in Android using Kotlin’s sealed classes. The view state machine simplifies state management, enhances testability, and adapts to evolving UI requirements, addressing key challenges in Android development. By leveraging Kotlin’s type-safe features, Amanda’s methodology offers a reusable, maintainable framework that aligns with modern development practices. As Android developers increasingly adopt Kotlin, this approach underscores the language’s potential to streamline complex workflows, fostering robust and adaptable applications.
Links
[DotSecurity2017] DevOps and Security
In development’s dynamic deluge, where velocity’s vortex vanquishes venerable verities, security’s synthesis with speed spawns safer sanctums. Zane Lackey, Signal Sciences’ CTO and Etsy alumnus, shared this synthesis at dotSecurity 2017, recounting Etsy’s evolution from waterfall’s wane to DevOps’ dawn—100 deploys diurnal, security self-sufficiency’s sunrise. A sentinel schooled in scaling safeguards, Zane’s zeitgeist: shift from gatekeeper’s glower to enabler’s embrace, visibility’s vista vitalizing vigilance.
Zane’s zeitgeist zeroed on transformations: velocity’s vault (18 months to moments), infrastructure’s illusion (cloud’s churn, containers’ cadence), ownership’s osmosis (devs’ dominion over deploys). Security’s schism: outsourced obstruction to integrated impetus—feedback’s flux fostering fixes. Etsy’s ethos: blameless postmortems’ balm, chatops’ chorus—vulnerabilities vocalized via Slack’s summons, fixes’ fanfare.
Visibility’s vanguard: dashboards’ dawn, signals’ symphony—Signal Sciences’ sentry sensing surges. Feedback’s finesse: CI’s critique, pull requests’ probes—vulnerabilities voiced in vernacular. Zane’s vignette: researcher’s rapport, exploits eclipsed by ephemeral emends—positive parleys from proactive patches.
DevOps’ dividend: safety’s surge in speed’s slipstream—mortals empowered, mishaps mitigated.
Transformations’ Tide and Security’s Shift
Zane zeroed on zeal: velocity’s vault, cloud’s churn—ownership’s osmosis. Gatekeeper’s glower to enabler’s embrace.
Visibility’s Vista and Feedback’s Flux
Dashboards’ dawn, chatops’ chorus—CI’s critique, pull’s probes. Zane’s vignette: researcher’s rapport, ephemeral emends.
Links:
[ScalaDaysNewYork2016] Large-Scale Graph Analysis with Scala and Akka
Ben Fonarov, a Big Data specialist at Capital One, presented a compelling case study at Scala Days New York 2016 on building a large-scale graph analysis engine using Scala, Akka, and HBase. Ben detailed the architecture and implementation of Athena, a distributed time-series graph system designed to deliver integrated, real-time data to enterprise users, addressing the challenges of data overload in a banking environment.
Addressing Enterprise Data Needs
Ben Fonarov opened by outlining the motivation behind Athena: the need to provide integrated, real-time data to users at Capital One. Unlike traditional table-based thinking, Athena represents data as a graph, modeling entities like accounts and transactions to align with business concepts. Ben highlighted the challenges of data overload, with multiple data warehouses and ETL processes generating vast datasets. Athena’s visual interface allows users to define graph schemas, ensuring data is accessible in a format that matches their mental models.
Architectural Considerations
Ben described two architectural approaches to building Athena. The naive implementation used a single actor to process queries, which was insufficient for production-scale loads. The robust solution leveraged an Akka cluster, distributing query processing across nodes for scalability. A query parser translated user requests into graph traversals, while actors managed tasks and streamed results to users. This design ensured low latency and scalability, handling up to 200 billion nodes efficiently.
Streaming and Optimization
A key feature of Athena, Ben explained, was its ability to stream results in real time, avoiding the batch processing limitations of frameworks like TinkerPop’s Gremlin. By using Akka’s actor-based concurrency, Athena processes queries incrementally, delivering results as they are computed. Ben discussed optimizations, such as limiting the number of nodes per actor to prevent bottlenecks, and plans to integrate graph algorithms like PageRank to enhance analytical capabilities.
Future Directions and Community Engagement
Ben concluded by sharing future plans for Athena, including adopting a Gremlin-like DSL for graph traversals and integrating with tools like Spark and H2O. He emphasized the importance of community feedback, inviting developers to join Capital One’s data team to contribute to Athena’s evolution. Running on AWS EC2, Athena represents a scalable solution for enterprise graph analysis, poised to transform how banks handle complex data relationships.
Links:
[KotlinConf2017] What’s New & Cool in Kotlin Tools
Lecturer
Dmitry Jemerov is a senior software engineer and the Kotlin IDE team lead at JetBrains, where he drives the development of tools and plugins to enhance Kotlin’s developer experience. With extensive experience in building IntelliJ IDEA plugins and supporting build tools like Gradle, Maven, and Ant, Dmitry has played a pivotal role in shaping Kotlin’s ecosystem. His leadership ensures that Kotlin’s tooling aligns with the language’s pragmatic design, fostering productivity across diverse development environments.
Abstract
Kotlin’s tooling ecosystem is integral to its success as a modern programming language, enabling developers to create efficient, cross-platform applications. This article analyzes Dmitry Jemerov’s presentation at KotlinConf 2017, which showcases new features in the Kotlin plugin for IntelliJ IDEA, with a focus on version 1.2 enhancements. It explores the context of Kotlin’s tooling evolution, the methodology behind multiplatform project support, incremental compilation advancements, and integration with build systems. The analysis highlights the implications of these innovations for developer productivity and cross-platform development, emphasizing Kotlin’s commitment to seamless, high-performance workflows.
Context of Kotlin Tooling Evolution
KotlinConf 2017, held in San Francisco from November 1–3, 2017, marked a significant milestone for Kotlin, reflecting its rapid adoption following Google’s endorsement for Android development. Dmitry Jemerov’s presentation focused on the Kotlin plugin for IntelliJ IDEA, a cornerstone of the language’s developer experience. As Kotlin expanded beyond JVM-based applications to multiplatform projects, including JavaScript and native targets, the need for robust tooling became paramount. Dmitry’s talk addressed this demand, showcasing features designed to streamline development across diverse platforms while maintaining Kotlin’s hallmark simplicity and interoperability.
The context of Dmitry’s presentation reflects the challenges of supporting a versatile language like Kotlin, which targets JVM, JavaScript, and native platforms. Developers required tools that could handle common and platform-specific code seamlessly, integrate with build systems like Gradle, and optimize compilation for performance. Dmitry’s leadership in the Kotlin IDE team positioned him to address these needs, demonstrating how JetBrains’ tools empower developers to tackle complex, multiplatform projects with efficiency and confidence.
Multiplatform Project Support
Dmitry’s methodology for supporting multiplatform projects centers on structuring Kotlin projects into common and platform-specific modules. Common modules contain shared Kotlin code, ensuring reusability across platforms, while platform-specific modules incorporate language-specific code, such as Java for JVM or JavaScript for web applications. The Kotlin compiler integrates these modules, producing artifacts like JAR files or APKs tailored to each platform’s requirements. This approach enables developers to write shared business logic once, reducing duplication and ensuring consistency across Android, iOS, and web environments.
In his live demos, Dmitry showcased how IntelliJ IDEA’s Kotlin plugin facilitates this structure, providing seamless navigation between common and platform-specific code. The plugin’s ability to combine common Kotlin code with platform-specific sources, such as Java for JVM modules, streamlines the build process. This methodology enhances developer productivity by simplifying project configuration and ensuring that multiplatform development remains intuitive, even for complex applications spanning multiple targets.
Incremental Compilation and Build Optimization
A key innovation highlighted by Dmitry was the advancement of incremental compilation across Kotlin’s target platforms. Incremental compilation optimizes build times by recompiling only modified code, a critical feature for large projects. For JVM targets, incremental compilation was already robust, but Dmitry announced the near-completion of JavaScript incremental compilation for Kotlin 1.1.6, with plans to extend it to native and multiplatform projects. This ensures that developers experience minimal delays during development, even in complex, multi-module environments.
Dmitry also emphasized integration with Gradle’s build cache and incremental compilation features, aligning Kotlin’s tooling with industry-standard build systems. By embedding IntelliJ inspections into continuous integration pipelines like TeamCity, the Kotlin plugin enables automated code quality checks, failing builds when issues exceed defined thresholds. This methodology reduces manual oversight, ensuring that code quality remains high without impeding development speed, particularly for teams managing large codebases.
IDE Integration and Developer Experience
The Kotlin plugin for IntelliJ IDEA enhances developer experience through advanced IDE features, such as code completion, refactoring, and inspections. Dmitry demonstrated how the plugin supports multiplatform projects with context-aware suggestions, simplifying the development of common and platform-specific code. The plugin’s integration with IntelliJ’s CI server allows for real-time code analysis, catching potential issues during builds. This seamless integration ensures that developers can focus on coding rather than configuring tools, aligning with Kotlin’s philosophy of getting out of the developer’s way.
Dmitry’s presentation also highlighted the plugin’s configurability, allowing developers to customize inspections and thresholds to suit project needs. While acknowledging the current limitations, such as slower inspection speeds, he outlined plans for future optimizations, including SonarQube integration. These enhancements underscore JetBrains’ commitment to delivering a fast, unobtrusive development experience, making Kotlin’s tooling a competitive advantage for multiplatform and high-performance applications.
Implications for Software Development
The advancements in Kotlin’s tooling, as presented by Dmitry, have profound implications for software development. Multiplatform project support enables developers to create unified codebases for diverse platforms, reducing maintenance costs and fostering code reuse. Incremental compilation and build optimizations address the performance bottlenecks of large-scale projects, enhancing productivity for teams working on Android, web, or native applications. The integration of IDE features with build systems ensures consistent code quality, making Kotlin a compelling choice for enterprises and startups alike.
For the broader ecosystem, these tools strengthen Kotlin’s position as a versatile, developer-friendly language. The ability to seamlessly integrate with Gradle and IntelliJ IDEA positions Kotlin as a leader in modern development workflows, challenging traditional languages like Java. Dmitry’s invitation for community feedback at JetBrains’ booth and office hours reflects a collaborative approach, ensuring that tooling evolves in response to real-world needs. As Kotlin’s ecosystem grows, its tooling innovations will continue to drive adoption across diverse development domains.
Conclusion
Dmitry Jemerov’s presentation at KotlinConf 2017 illuminated the transformative potential of Kotlin’s tooling, particularly with the IntelliJ IDEA plugin’s version 1.2 enhancements. By supporting multiplatform projects, optimizing incremental compilation, and integrating with build systems, these tools empower developers to create efficient, cross-platform applications. The focus on developer experience, through intuitive IDE features and automated inspections, aligns with Kotlin’s pragmatic design philosophy. As JetBrains continues to refine these tools, they solidify Kotlin’s role as a leading language for modern software development, fostering productivity and innovation.
Links
[ScalaDaysNewYork2016] Implicits Inspected and Explained: Demystifying Scala’s Power
At Scala Days New York 2016, Tim Soethout, a functional programmer at ING Bank, offered a comprehensive guide to Scala’s implicits, a feature often perceived as magical by developers transitioning from basic to advanced Scala programming. Tim’s presentation bridged this gap, providing clear explanations and practical examples to demonstrate how implicits enhance code expressiveness and flexibility.
Understanding Implicits
Tim Soethout began by defining implicits as a mechanism for providing values or conversions without explicit references, enabling concise and flexible code. Drawing parallels with object-oriented programming, Tim explained that implicits extend “is-a” and “has-a” relationships with “is-viewable-as,” allowing developers to add rich interfaces to existing types. For instance, in Akka, the ! (tell) operator uses an implicit sender parameter, simplifying message passing. Similarly, Scala’s Futures rely on implicit execution contexts to manage asynchronous operations, abstracting thread scheduling from developers.
Compiler Resolution of Implicits
A key focus of Tim’s talk was demystifying how the Scala compiler resolves implicits. He outlined the compiler’s search process, which prioritizes local scope, companion objects, and package objects related to the involved types. Tim cautioned against implicit conversions with mismatched semantics, as they can lead to unexpected behavior. Using a live coding demo, he illustrated how implicits enable expressive DSLs, such as JSON serialization libraries, by automatically resolving type-specific writers, thus reducing boilerplate code.
Type Classes and Extensibility
Tim explored type classes as a powerful application of implicits, allowing non-intrusive library extensions. By defining behaviors like JSON serialization in companion objects, developers can extend functionality without modifying core libraries. He demonstrated this with a JSON writer example, where implicits ensured type-safe serialization for complex data structures. Tim emphasized that this approach fosters loose coupling, making libraries more modular and easier to maintain.
Practical Debugging Tips
Addressing common challenges, Tim offered strategies for debugging implicits, such as inspecting bytecode or leveraging IDEs to trace implicit resolutions. He warned against chaining multiple implicit conversions, as the compiler restricts itself to a single conversion to avoid complexity. By sharing practical examples, Tim equipped developers with the tools to harness implicits effectively, ensuring they enhance rather than obscure code clarity.
Links:
[KotlinConf2017] Cords & Gumballs
Lecturer
Mike Hearn is the lead platform engineer at R3, a consortium of leading financial institutions developing Corda, a blockchain-inspired distributed ledger platform implemented in Kotlin. With nearly eight years at Google as a senior software engineer and five years as a Bitcoin developer, Mike brings extensive experience in JVM-based development and distributed systems. His early adoption of Kotlin, 18 months before its 1.0 release, and his work on the open-source BitcoinJ library, used in products with millions of users, highlight his expertise in high-performance, scalable software solutions.
Abstract
Kotlin’s versatility enables both large-scale enterprise projects and lightweight command-line tools. This article analyzes Mike Hearn’s presentation at KotlinConf 2017, which explores two contrasting projects: Corda, a blockchain-inspired platform for financial institutions, and Gumballs, a tool for generating standalone native binaries from Kotlin/JVM code. The analysis examines the context of Kotlin’s adoption in enterprise and lightweight applications, the methodologies behind Corda and Gumballs, their technical innovations, and their implications for software development. Mike’s insights highlight Kotlin’s ability to address diverse use cases, from secure financial systems to efficient command-line utilities.
Context of Kotlin in Enterprise and Lightweight Applications
At KotlinConf 2017, Mike Hearn presented two distinct projects showcasing Kotlin’s flexibility. Corda, developed by R3, is a large-scale enterprise platform inspired by blockchain technology, designed to streamline financial transactions among banks. Implemented entirely in Kotlin, Corda leverages the language’s concise syntax and JVM compatibility to handle complex business logic securely. In contrast, Gumballs is a side project that compiles Kotlin/JVM code into standalone native binaries, competing with Go’s efficiency for command-line tools. This dual focus reflects Kotlin’s ability to cater to both enterprise-scale systems and lightweight, performance-critical applications.
The context of Corda’s development highlights Kotlin’s appeal for enterprise use. Mike, an early Kotlin adopter, chose the language for its compatibility with the JVM, which is well-suited for high-level business logic in financial systems. The decision to avoid web technologies like TornadoFX, due to security concerns, underscores Corda’s emphasis on robust, desktop-based applications. Gumballs, conversely, addresses the need for efficient, standalone tools, demonstrating Kotlin’s potential to rival Go in scenarios requiring minimal dependencies and fast execution.
Methodology of Corda and Gumballs
Corda’s methodology centers on leveraging Kotlin’s features to build a secure, scalable distributed ledger. Mike explained that Corda uses Kotlin’s type safety and concise syntax to implement complex financial workflows, such as peer-to-peer real-time gross settlement systems. The platform employs cryptographic identities for nodes, ensuring stronger security than traditional systems reliant on identifiers like social security numbers. Kotlin’s interoperability with the JVM allows Corda to integrate with existing financial infrastructure, while its open-source nature, with tutorials and sample apps, encourages developer adoption.
Gumballs, in contrast, focuses on generating ahead-of-time compiled native binaries from Kotlin/JVM code. Mike demonstrated how Gumballs produces lightweight executables, similar to Go’s output, by compiling Kotlin code into native binaries that run without a JVM. This approach minimizes dependencies, making it ideal for command-line utilities requiring fast startup and execution. The methodology leverages Kotlin’s compiler capabilities, showcasing its flexibility beyond traditional JVM applications and highlighting its potential for cross-platform, performance-critical tasks.
Technical Innovations and Challenges
Corda’s technical innovations include its use of Kotlin to manage complex state and transaction logic in a distributed environment. Mike highlighted how Kotlin’s concise syntax reduces boilerplate, enabling developers to focus on business logic rather than infrastructure. The platform’s participation in a competition with the Central Bank of Singapore to develop a settlement system demonstrated its ability to handle real-world financial challenges. However, challenges like ensuring security in distributed systems required banning less secure web technologies, favoring managed desktop apps for structural integrity.
Gumballs introduces a novel approach to Kotlin compilation, producing standalone binaries that compete with Go’s efficiency. This innovation addresses the need for lightweight tools in scenarios where JVM overhead is impractical. Challenges included optimizing the compilation process to minimize binary size and ensure compatibility across platforms. Mike’s presentation emphasized the experimental nature of Gumballs, inviting community feedback to refine its capabilities, reflecting the iterative approach to developing new Kotlin tools.
Implications for Software Development
Corda and Gumballs demonstrate Kotlin’s versatility across the spectrum of software development. Corda’s adoption by a consortium of banks underscores Kotlin’s suitability for enterprise applications requiring security, scalability, and interoperability. Its open-source model, supported by tutorials and sample apps, lowers the barrier to entry for developers building financial systems. Gumballs, meanwhile, expands Kotlin’s reach into lightweight, performance-critical applications, offering an alternative to languages like Go for command-line tools and utilities.
For developers, these projects highlight Kotlin’s ability to unify diverse development needs within a single language. Corda’s success in enterprise settings encourages adoption in industries requiring robust, secure systems, while Gumballs appeals to developers seeking efficient, standalone solutions. The broader implication is Kotlin’s potential to challenge established languages in both enterprise and niche domains, fostering a more cohesive development ecosystem. Mike’s call for community contributions via Corda’s open-source platform and Gumballs’ experimental development further amplifies Kotlin’s collaborative potential.
Conclusion
Mike Hearn’s presentation at KotlinConf 2017 showcased Kotlin’s remarkable adaptability through Corda and Gumballs. Corda’s enterprise-grade blockchain platform demonstrates Kotlin’s strength in handling complex, secure financial systems, while Gumballs highlights its potential for lightweight, high-performance tools. By leveraging Kotlin’s type safety, JVM compatibility, and concise syntax, both projects address distinct challenges, from distributed ledgers to native binaries. As Kotlin continues to evolve, Mike’s insights underscore its transformative role in software development, inspiring developers to explore its capabilities across diverse domains.
Links
[DotSecurity2017] The Digital Battle
In the digital domain’s relentless ruckus, where innovation’s influx intersects with iniquity’s ingenuity, safeguarding society’s sinews demands diligence beyond devices. Mikko Hypponen, F-Secure’s chief research officer, surveyed this skirmish at dotSecurity 2017, chronicling connectivity’s costs—from Nokia’s nadir to IoT’s insurgency. A Finnish fixture in antivirus annals since 1991, Mikko’s métier—malware’s myriad manifestations—manifests in missives that marry menace with mitigation, urging unity against ubiquitous threats.
Mikko’s meditation meandered through time: 2007’s iPhone ingress, internet’s ingress into pockets—privacy’s payment in profiles. Youth’s yen: videos’ vista via Google’s gaze, data’s donation. Privacy’s plight: perhaps perished, yet security’s skirmish salvageable—society’s stake superseding screens. Criminality’s calculus: crime’s commoditization, ransomware’s rise—CryptoWall’s coffers crammed $325M, victims’ vigil via NoMoreRansom’s nexus.
IoT’s incursion: Mirai’s maelstrom, 600,000 conscripts cascading DDoS—Dyn’s downfall, Krebs’ knockout. Mikko’s maxim: defaults’ delinquency, patches’ paucity—devices’ disposability dooms defense. Refrigerators’ reconnaissance, lamps’ liabilities—cloud’s collapse cascades chaos, AWS’s outage orphaning ovens.
Hope’s harbinger: IKEA’s integrity, investment’s imperative—security’s sanctity secures society.
Innovation’s Influx and Privacy’s Peril
Mikko mapped metamorphosis: Nokia’s nosedive, iPhone’s incursion—privacy’s price, data’s dues.
Malware’s Myriad and IoT’s Insurgency
Ransomware’s ransom, Mirai’s muster—Dyn’s deluge, defaults’ danger. Cloud’s crumble, chaos cascades.
Links:
[DevoxxFR 2017] Introduction to the Philosophy of Artificial Intelligence
The rapid advancements and increasing integration of artificial intelligence into various aspects of our lives raise fundamental questions that extend beyond the purely technical realm into the domain of philosophy. As machines become capable of performing tasks that were once considered uniquely human, such as understanding language, recognizing patterns, and making decisions, we are prompted to reconsider our definitions of intelligence, consciousness, and even what it means to be human. At DevoxxFR 2017, Eric Lefevre Ardant and Sonia Ouchtar offered a thought-provoking introduction to the philosophy of artificial intelligence, exploring key concepts and thought experiments that challenge our understanding of machine intelligence and its potential implications.
Eric and Sonia began by acknowledging the pervasive presence of “AI” in contemporary discourse, noting that the term is often used broadly to encompass everything from simple algorithms to hypothetical future superintelligence. They stressed the importance of developing a critical perspective on these discussions and acquiring the vocabulary necessary to engage with the deeper philosophical questions surrounding AI. Their talk aimed to move beyond the hype and delve into the core questions that philosophers have grappled with as the possibility of machine intelligence has become more concrete.
The Turing Test: A Criterion for Machine Intelligence?
A central focus of the presentation was the Turing Test, proposed by Alan Turing in 1950 as a way to determine if a machine can exhibit intelligent behavior equivalent to, or indistinguishable from, that of a human. Eric and Sonia explained the setup of the test, which involves a human interrogator interacting with both a human and a machine through text-based conversations. If the interrogator cannot reliably distinguish the machine from the human after a series of conversations, the machine is said to have passed the Turing Test.
They discussed the principles behind the test, highlighting that it focuses on observable behavior (linguistic communication) rather than the internal workings of the machine. The Turing Test has been influential but also widely debated. Eric and Sonia presented some of the key criticisms of the test, such as the argument that simulating intelligent conversation does not necessarily imply true understanding or consciousness.
The Chinese Room Argument: Challenging the Turing Test
To further explore the limitations of the Turing Test and the complexities of defining machine intelligence, Eric and Sonia introduced John Searle’s Chinese Room argument, a famous thought experiment proposed in 1980. They described the scenario: a person who does not understand Chinese is locked in a room with a large set of Chinese symbols, a rulebook in English for manipulating these symbols, and incoming batches of Chinese symbols (representing questions). By following the rules in the rulebook, the person can produce outgoing batches of Chinese symbols (representing answers) that are appropriate responses to the incoming questions, making it appear to an outside observer that the person understands Chinese.
Sonia and Eric explained that Searle’s argument is that even if the person in the room can pass the Turing Test for understanding Chinese (by producing seemingly intelligent responses), they do not actually understand Chinese. They are simply manipulating symbols according to rules, without any genuine semantic understanding. The Chinese Room argument is a direct challenge to the idea that passing the Turing Test is a sufficient criterion for claiming a machine possesses true intelligence or understanding. It raises profound questions about the nature of understanding, consciousness, and whether symbolic manipulation alone can give rise to genuine cognitive states.
The talk concluded by emphasizing that the philosophy of AI is a fertile and ongoing area of inquiry with deep connections to various other disciplines, including neuroscience, psychology, linguistics, and computer science. Eric and Sonia encouraged attendees to continue exploring these philosophical questions, recognizing that understanding the fundamental nature of intelligence, both human and artificial, is crucial as we continue to develop increasingly capable machines. The session provided a valuable framework for critically evaluating claims about AI and engaging with the ethical and philosophical implications of artificial intelligence.
Links:
- Video URL: https://www.youtube.com/watch?v=pDPFnywbWDo
Hashtags: #AI #ArtificialIntelligence #Philosophy #TuringTest #ChineseRoom #MachineIntelligence #Consciousness #EricLefevreArdant #SoniaOUCHTAR #PhilosophyOfAI
[ScalaDaysNewYork2016] Finagle Under the Hood: Unraveling Twitter’s RPC System
At Scala Days New York 2016, Vladimir Kostyukov, a member of Twitter’s Finagle team, provided an in-depth exploration of Finagle, a scalable and extensible RPC system written in Scala. Vladimir elucidated how Finagle simplifies the complexities of distributed systems, offering a functional programming model that enhances developer productivity while managing intricate backend operations like load balancing and circuit breaking.
The Essence of Finagle
Vladimir Kostyukov introduced Finagle as a robust RPC system used extensively at Twitter and other organizations. Unlike traditional application frameworks, Finagle focuses on facilitating communication between services, abstracting complexities such as connection pooling and load balancing. Vladimir highlighted its protocol-agnostic nature, supporting protocols like HTTP/2 and Twitter’s custom Mux, which enables efficient multiplexing. This flexibility allows developers to build services in Scala or Java, seamlessly integrating Finagle into diverse tech stacks.
Client-Server Dynamics
Delving into Finagle’s internals, Vladimir described its client-server model, where services are treated as composable functions. When a client sends a request, Finagle’s stack—comprising modules for connection pooling, load balancing, and failure handling—processes it efficiently. On the server side, incoming requests are routed through similar modules, ensuring resilience and scalability. Vladimir emphasized the “power of two choices” load balancing algorithm, which selects the least-loaded node from two randomly chosen servers, achieving near-optimal load distribution in constant time.
Advanced Features and Ecosystem
Vladimir showcased Finagle’s advanced capabilities, such as streaming support for large payloads and integration with tools like Zipkin for tracing and Twitter Server for monitoring. Libraries like Finatra and Featherbed further enhance Finagle’s utility, enabling developers to build RESTful APIs and type-safe HTTP clients. These features make Finagle a powerful choice for handling high-throughput systems, as demonstrated by its widespread adoption at Twitter for managing massive data flows.
Community and Future Prospects
Encouraging community engagement, Vladimir invited developers to contribute to Finagle’s open-source repository on GitHub. He discussed ongoing efforts to support HTTP/2 and improve performance, underscoring Finagle’s evolution toward a utopian RPC system. By offering a welcoming environment for pull requests and feedback, Vladimir emphasized the collaborative spirit driving Finagle’s development, ensuring it remains a cornerstone of scalable service architectures.