Detecting visibility bugs in concurrent Java
Chances to detect visibility bugs vary. The following visibility bug can in the best case detected in 90 percent of all cases. In the worst case, the chance to detect the bug is lower than one in a million.Read full article from Detecting visibility bugs in concurrent Java
During the course of our client engagements, there are a few common topics or themes that are always discussed, and the clients themselves usually introduce them. One such area is technical debt. Every team has it, every team believes they have too much of it, and every team struggles to explain why it's important to address it.
Let's start by defining what technical debt means. It is the difference between doing something the "desired" or "best" way and doing something quickly (i.e. reduce time to market). The difference results in the company taking on "debt" within the solution. Technical debt requires acting with forethought. In other words, you only assume technical debt knowingly and with commission. Acts of omission (forgetting to plan or do something) do not count as debt. Our partners in business may think we are hiding the truth if we do not clearly delineate the difference between debt (known assumptions) and mistakes, failures or other issues related to maintenance.
Read full article from Growth Blog | AKF Partners
This is not to say we should fill the world with noise on every mundane aspect of our existence. But who decides what is mundane? Who decides what is interesting? Everything's interesting to someone, even if that someone is only you and a few other people in the world.
It's my firm belief that the inclusionists are winning. We live in a world of infinitely searchable micro-content, and every contribution, however small, enriches all of us. But more selfishly, if you're interested in deriving maximum benefit from your work, there's no substitute for making it public and findable. Obscurity sucks. But obscurity by choice is irrational. When in doubt, make it public.
Read full article from When In Doubt, Make It Public
Buffer's Data Architecture: How We Analyze 500M Records in Seconds
Buffer is a data-driven company. So many of the decisions we make hinge on data that we collect and analyze. We track and measure analytics data for all kinds of things – user behavior, how our A/B experiments are running, as well as system-generated data such as API logs.
As outlined in this post by Sunil, we have built a pretty robust platform for tracking and measuring data, all powered by Amazon's SQS and MongoDB.
Read full article from Buffer's Data Architecture: How We Analyze 500M Records in Seconds
其中corePoolSize是线程池核心数目；maximumPoolSize线程池中线程的最大数目；keepAliveTime表示当线程数目大于core并且超过一定时间，会关闭多余的线程池；workQueue存放任务的线程；threadFactory创建线程的类；handler拒绝处理任务时的策略。
当调用 execute() 方法添加一个任务时，线程池会做如下判断：
如果线程池里线程数量小于corePoolSize，不管线程池里面的线程是否处于运行状态，那么马上创建线程运行这个任务；
如果线程池里线程数量大于或等于corePoolSize，那么将这个任务放入队列。
如果这时候队列满了，而且线程池里的线程数目小于maximumPoolSize，那么还是要创建线程运行这个任务；
如果队列满了，并且线程池里的线程数目达到maximumPoolSize，那么线程池就会执行handler策略。
Read full article from Java杂谈
How to make iOS 11 share JPGs instead of HEIC photos | Cult of Mac
The third option, which requires no apps, and will work on any computer including Windows PCs, is to toggle a setting on the iPhone. Head to Settings>Photos and scroll down to Transfer to Mac or PC. Here you can choose what format is sent to a computer when you plug it in. I tested this using Image Capture app on the Mac (you'll find it in your Applications folder). With the iPhone set to "Automatic," photos show up as JPGs on the Mac. With it set to "Keep Originals," the HEIC file is transferred. This lets you archive either the original photo, or save the picture in a more compatible format (JPG).
Read full article from How to make iOS 11 share JPGs instead of HEIC photos | Cult of Mac
Read full article from Paypal:My browser sent a request that server could not understand. Size of a request header field exceeds server limit. - Google Product Forums
SIGTERM vs. SIGKILL - major.io
Sending signals to processes using kill on a Unix system is not a new topic for most systems administrators, but I've been asked many times about the difference between kill and kill -9.
Anytime you use kill on a process, you're actually sending the process a signal (in almost all situations – I'll get into that soon). Standard C applications have a header file that contains the steps that the process should follow if it receives a particular signal. You can get an entire list of the available signals on your system by checking the man page for kill.
Read full article from SIGTERM vs. SIGKILL - major.io
Google Home will play music and sound effects when you read Disney storybooks - The Verge
Google has partnered with Disney to enhance story time reading with the Google Home. Now you can start reading one of Disney's Little Golden Books out loud and your Google Home device will play music and relevant sound effects along with you.
To use the new feature, just say, "Hey Google, let's read along with Disney." Then the Google Home will use voice recognition to sense where you are in the story. If you decide to flip ahead or go backward in the story, say if your kid asks you to repeat a fun part, your Google Home will sense that and switch its music and sounds to reflect where you are. If you pause, perhaps because your kid has a question, the Google Home will play ambient music in the background until you start reading again. (Since the feature depends entirely on voice recognition, if you were to flip a few pages without saying a word, it wouldn't be able to tell.)
Read full article from Google Home will play music and sound effects when you read Disney storybooks - The Verge
Java's difficulties with Functional Programming - JDriven
In my early days I spent most of my time fixing bugs on a huge enterprise application, so by now I learned from experience that a lot of bugs could have been easily prevented. This is why I prefer a Functional Programming style, I love how FP handles state. As a software consultant I get to switch companies and teams quite regularly and most projects I have been working on use java 7 or 8. This almost always leads to a few dicussions regarding programming style. So today I would like to talk about good FP principles, and how Java makes them hard (and why languages like Kotlin are awesome).
Read full article from Java's difficulties with Functional Programming - JDriven
最近重读了Spanner的论文，之前所困惑的Commit Wait等概念终于有了新的理解，也发现了文章中的更多细节。这里整理出十个重点问题，旨在理清诸多设计细节。
Read full article from Spanner十问 - 知乎
组件是软件部署的最小单元，是整个软件系统在部署过程中可以独立完成部署的最小实体。比如，对于Java应用程序而言，Jar包就是组件；Ruby中的组件则是Gem文件；Python中的Egg或Wheel文件以及.Net下的DLL文件。
上回我们说到，编程范式的本质是约束。子过程、类或函数是我们编程过程中的基本元素，所以说编程范式是程序的基础构件。如果将这些基本构件比作建筑里的泥沙石，那么程序中的组件就可以类比成砖头。砖头的工艺注重材料配比，组件也是如此，恰如其分的基础构件配比是组件稳定的基础。组件的内容配比较难定量，但是在实践上，仍然受到指导原则的约束。
Read full article from 架构整洁之道导读（二） - 简书
setcookie - Cookies on localhost with explicit domain - Stack Overflow
By design, domain names must have at least two dots; otherwise the browser will consider them invalid. (See reference on http://curl.haxx.se/rfc/cookie_spec.html)
When working on localhost, the cookie domain must be omitted entirely. Just setting it to "" or NULL or FALSE instead of "localhost" is not enough.
Read full article from setcookie - Cookies on localhost with explicit domain - Stack Overflow
Random App Ideas - Bozho's tech blog
Every now and then you start thinking "wouldn't it be nice to have an app for X". When I was in that situation, I took a note. Then that note grew, I cleaned up some absurd ones and added some more. I implemented some of these ideas of mine, the rest formed a "TODO" list.
At some point I realized I won't be able to implement them, as the time needed is not something I'm likely to have in the near future. But I didn't like to just delete the notes. So here they are – my random app ideas. Probably useless, but maybe a little interesting.
Read full article from Random App Ideas - Bozho's tech blog
Observing the result of step operations may affect the speed of execution, which may become unusable if this takes too long. To solve this problem, a timeout (default: 7000 ms) has been introduced after which the observation mechanism is disabled until the end of the step operation.
There's a new option in the Debug view to show or hide running threads. This is helpful when debugging heavily multithreaded application when you have to find threads stopped at breakpoints among hundreds or thousands of running threads.
Speaking of new and newsworthy, there's also a new button Show Command Line which has been added in the Java Launch Configuration dialog. If you click the button, a dialog which shows the command line used for launching the application will open.
Read full article from Eclipse 4.9 marks the beginning of the Eclipse Foundation's quarterly Simultaneous Release - JAXenter
Apache Kafka 从 0.11.0 开始，支持了一个非常大的 feature，就是对事务性的支持，在 Kafka 中关于事务性，是有三种层面上的含义：一是幂等性的支持；二是事务性的支持；三是 Kafka Streams 的 exactly once 的实现，关于 Kafka 事务性系列的文章我们只重点关注前两种层面上的事务性，与 Kafka Streams 相关的内容暂时不做讨论。社区从开始讨论事务性，前后持续近半年时间，相关的设计文档有六十几页（参考 Exactly Once Delivery and Transactional Messaging in Kafka）。事务性这部分的实现也是非常复杂的，之前 Producer 端的代码实现其实是非常简单的，增加事务性的逻辑之后，这部分代码复杂度提高了很多，本篇及后面几篇关于事务性的文章会以 2.0.0 版的代码实现为例，对这部分做了一下分析，计划分为五篇文章：
Read full article from Kafka 事务性之幂等性实现 | Matt's Blog
在10月22的 Oracle Codeone大会上，Java平台的首席架构师 Mark Reinhold 做了The Future of Java is Today的演讲， 回顾了最近Java的几个版本的新的功能，Java的每年两次的发布周期， 澄清了关于发布流程和Java版本的几个误区，最后花了很大的篇幅介绍了未来Java几个令人非常期待的几个孵化中项目，可以为Java带来更好的生产力、性能和可扩展性。我整理了这四个项目相关的知识，你可以提前了解到Java未来的这些酷炫的特性。
Read full article from Java: 未来已来 | 鸟窝
12 Habits that can Boost Women's Promotion - Tian Pan's Notes
Disclaimer: I highly doubt those guys who succeed only by giving advice on how to succeed. A bird's flight does not need the guidance of ornithologists. Anyhow, food for thought that these are what American women think helpful to their promotions.
Read full article from 12 Habits that can Boost Women's Promotion - Tian Pan's Notes
What can we communicate in soft skills interview? - Tian Pan's Notes
An interview is a process for workers to find future co-workers, during which they are finding signals to answer the following three key questions:
Read full article from What can we communicate in soft skills interview? - Tian Pan's Notes
Solr Terms Query for matching many terms - Solr 'n Stuff
Solr 4.10 and Heliosearch .07 have added a terms query (or terms filter) to more efficiently match many terms in a single field.
A large number of terms are often useful for things like access control lists or security filters. Previously, the only way to do this was a large boolean query with many clauses, which has unnecessary overhead when scoring is not needed.
Solr's implementation uses Lucene's TermFilter class, as does Elasticsearch's terms filter.
The Heliosearch terms query implementation has some additional features:
Read full article from Solr Terms Query for matching many terms - Solr 'n Stuff
How to Generate Java Thread Dump Programmatically • Crunchify
The thread dump is a snapshot of exactly what's executing at a moment in time in your Java Program.
While the thread dump format and content may vary between the different Java vendors, at the bare minimum it provides you a list of the stack traces for all Java threads in the Java Virtual Machine.
Using this information, you can either analyze the problem yourself, or work with those who wrote the running code to analyze the problem.
Thread dump is just a list of all threads and the full stack trace of code running on each thread. If you are a J2EE Application Server administrator and you've never done development before, the concept of a stack trace may be foreign to you.
Read full article from How to Generate Java Thread Dump Programmatically • Crunchify
最近在做一个基于 Websocket 的长连中间件，服务端使用实现了 Socket.IO 协议（基于WebSocket协议，提供长轮询降级能力） 的 netty-socketio 框架，该框架为 Netty 实现，鉴于本人对 Netty 比较熟，并且对比同样实现了 Socket.IO 协议的其他框架，Netty 的口碑都要更好一些，因此选择这个框架作为底层核心。
诚然，任何开源框架都避免不了 Bug 的存在，我们在使用这个开源框架时，就遇到一个堆外内存泄露的 Bug。美团的价值观一直都是"追求卓越"，所以我们就想挑战一下，找到那只臭虫（Bug），而本文就是遇到的问题以及排查的过程。当然，想看结论的同学可以直接跳到最后，阅读总结即可。
Read full article from Netty堆外内存泄露排查盛宴 -
Redis 的 KEYS 命令引起 RDS 数据库雪崩，宕机 2 次，造成几百万损失 - 文章 - 伯乐在线
最近的互联网线上事故发生比较频繁，9月19日网上爆料出顺丰近期发生了一起线上删库事件，在这里就不介绍了。
在这里讲述一下最近发生在我公司的事故，以及如何避免，并且如何处理优化。 该宕机的直接原因是使用 Redis 的 keys * 命令引起的，一共造成了某个服务化项目的两次宕机。
间接原因还有很多，技术跟不上业务的发展，由每日百万量到千万级是一个大的跨进，公司对于系统优化的处理优先级不高，技术开发人手的短缺。
Read full article from Redis 的 KEYS 命令引起 RDS 数据库雪崩，宕机 2 次，造成几百万损失 - 文章 - 伯乐在线
利用责任链模式设计一个拦截器 | crossoverJie's Blog
近期在做 Cicada 的拦截器功能，正好用到了责任链模式。
这个设计模式在日常使用中频率还是挺高的，借此机会来分析分析。
先来看看什么是责任链模式。
引用一段维基百科对其的解释：
责任链模式在面向对象程式设计里是一种软件设计模式，它包含了一些命令对象和一系列的处理对象。每一个处理对象决定它能处理哪些命令对象，它也知道如何将它不能处理的命令对象传递给该链中的下一个处理对象。该模式还描述了往该处理链的末尾添加新的处理对象的方法。
光看这段描述可能大家会觉得懵，简单来说就是该设计模式用于对某个对象或者请求进行一系列的处理，这些处理逻辑正好组成一个链条。
下面来简单演示使用与不使用责任链模式有什么区别和优势。
Read full article from 利用责任链模式设计一个拦截器 | crossoverJie's Blog
Xml and More: JMetesr—How to Load Test CSRF-Protected Web Sites
Read full article from Xml and More: JMetesr—How to Load Test CSRF-Protected Web Sites
java.io.BufferedInputStream and java.util.zip.GZIPInputStream - Java Performance Tuning Guide
BufferedInputStream and GZIPInputStream are two classes often used while reading some data from a file (the latter is widely used at least in Linux). Buffering input data is generally a good idea which was described in many Java performance articles. There are still a couple of issues worth knowing about these streams.
Read full article from java.io.BufferedInputStream and java.util.zip.GZIPInputStream - Java Performance Tuning Guide
java.util.zip.GZIPInputStream / GZIPOutputStream. java.util.zip.DeflaterOutputStream / InflaterInputStream. Read full article from Performance of various general compression algorithms - some of them are unbelievably fast! - Java Performance Tuning Guide
LZ4BlockOutputStream-s with 32M buffer size to get most out of LZ4. Read full article from Performance of various general compression algorithms - some of them are unbelievably fast! - Java Performance Tuning Guide
A Love Letter to Lambda Logging – The Symphonium
As an author of Java-based AWS Lambda functions, I've been generally impressed with the quality of the Java runtime for Lambda, as well as the supporting libraries that AWS provides.
However, the current Java Lambda logging library, aws-lambda-java-log4j, is an outlier, in that it brings an almost five year old version of an unmaintained logging package into your Lambda project as a transitive dependency. This is an unfortunate state of affairs for an otherwise very modern Serverless platform.
Read full article from A Love Letter to Lambda Logging – The Symphonium
HotSpot JVM throwing OOM even when there is memory available | Poonam Bajaj's Blog
I was recently asked a question that why my Java application runs out of Java Heap when there is still so much memory available to use?
Here is the question in detail - I am running my application with -Xmx1600m but the logs show that it runs out of memory without fully using the 1600mb.
Read full article from HotSpot JVM throwing OOM even when there is memory available | Poonam Bajaj's Blog
java - Identify old gen in heap dump (or take heap dump of old gen only) - Stack Overflow
seeing some things propagate to old gen isn't a huge concern. After your old gen reaches a certain threshold a full GC will kick off. If that isn't able to reclaim the memory then you have an issue. The fact that you are seeing some memory allocated during a young collection shouldn't be an alarming concern.
lots of time passed between memory being allocated and it spilling to old gen. Hence - a memory leak. I think
Not really.. just because memory is being added to old gen doesn't mean it is a memory leak. It is normal practice during a young collection that older objects get promoted to old gen. It is during those young collections when older objects get added to the old gen. This may just be your application still ramping up. In large scale applications there may be features not used every day, which may be getting into memory later then you expected.
That being said, if you really are concerned with any memory being added to the old gen and want to investigate further, I would recommend running this application on a demo environment. Attach a profiler (VisualVM will work) and load test (JMeter is good and free) your application. If you look at the objects you can get an idea of what generation an object is. You also want to see what happens when your old gen reaches a threshold where a full GC will kick off (normally in the 70%-90% range). If your old gen recovers back to the 20% threshold, then there is no leak. In some cases the old gen may never reach the point where a full GC gets kicked off, but instead level off as you expected. The load test will help identify that.
Read full article from java - Identify old gen in heap dump (or take heap dump of old gen only) - Stack Overflow
我支持将逻辑写在 Java 等应用系统中。其实原因在上面基本描述完了，第一就是复杂 SQL 的表关联其实跟个人的能力有非常大的关系，如果一个 SQL 写得不好，那是极慢极慢的非常容易把整个数据库拖慢的。第二就是维护这些 SQL 也是一件很难受的事情，因为你完全不知道这个 SQL 背后的数据流转是怎样的，你只能根据自己的猜测去查看 SQL 中的 bug，Java 应用好歹还能 debug 一下还有打点看看数据不是？如果逻辑写在 Java 中那么其实你的 DAO 层只需要编写一次，但是可以永久使用，基本不会在这一层浪费很多的时间（用过 ibatis 的都知道改了 SQL 需要重启应用吧？）。第三就是逻辑都写在 SQL ，中对于分库分表和应用拆分来说是一件非常难受的事情，真的难受。
Read full article from 慢SQL，压垮团队的最后一根稻草No.92 - 知乎
正所谓知己知彼，百战不殆。我们只需要弄清楚他们想要什么信息，那么我们就可以给出对应的信息即可。那么HR最关心什么信息呢？
所以，自我介绍的时候不要说自己喜欢打羽毛球或者游泳了，企业是雇你来干活的，不是让你来做运动教练的。事先准备好自我介绍，这样说的时候就不会卡顿，让HR觉得你的表达能力，不说好吧，最起码，不差。可以简略的介绍一下之前做什么，做过什么，什么职位，至于为什么离职，HR会问你的，不说也罢。如果有什么不正常的经历，可以主动说明。
当然，这并不是希望你利用"知己知彼"去骗HR或者怎样，诚实永远是第一位的。
举个例子：
我叫xxx，2016年毕业于xxx大学xxx专业。曾经任职于xxx公司担任xxx，完成了xxx功能，之后就职于xxx公司，担任了xxx，完成了 xxx功能。主要的兴趣在于高并发，平时也挺喜欢研究代码。这是我的一个基本的自我介绍。 当然，实际自我介绍的时候，应当把这一段稍微扩充一下，显得更有内容一些。
"首先，我们需要一个数据库，数据库的架构是。。。" --- 面对此类问题，你是否直接就开始回答了？错！大错特错！此类题目最大的坑就在于这里 --- 题目太过于宽泛，你所假定的并不一定是面试官所假定的。
因此，回答此类问题的第一个要记住的的地方就是 --- 一定要确定好所有的条件再开始答题 。千万不能想都不想就开是自以为是的假定一切数据，然后开始答题。以第一个题目为例，你可以反问面试官：
当你提出问题之后，面试官可能会回答你：
那么根据经验，我们可以知道，如果直接用一般配置的关系型数据库来扛6k/s，还是有点小压力的，流量只要再往上蹭，很有可能就会挂。但是，目前来说，题目还是不够清晰，我们还需要把我们想要做的假定向面试官问清楚：
如果面试官回答是，那么我们所需要的一些基本数据便有了，我们需要设计一个论坛，这个论坛大概有10万用户，高峰时期QPS大概在6k/s，但是一个优秀的架构是可以轻松应对高峰时期的。相比最开始的题目"请设计一个论坛"是不是更清晰多了呢？这种时候我们再开始设计，把我们的设计从上往下（概述）讲述出来，先讲概况，再讲细节，最好能在白板上将架构图画出来。此外，建议平时多看看架构设计类的文章，例如StackOverflow的架构：https://nickcraver.com/blog/2016/02/17/stack-overflow-the-architecture-2016-edition/。
回答时再加上自己的见解和如此设计的理由，就完美了。
毕业后到现在一共经历了三家公司。第一家是创业公司，开发团队10人不到。第二家是大企业内部的创业团队，开发团队大约40人。现在是一家比较大的大公司，开发团队人数规模不便透露。可以说我把类似毕业后去小公司还是大公司的这些问题里各类答案都经历了一遍。
先抛出最想说明的观点：
自驱力是技术人成长的不二法则。无论业务是To B或者To C，都会有一套对应的技术栈，如果只是满足于会用，是无法长久进步的。例如，使用Redis做缓存，就可以了解缓存的常见策略，了解Redis是怎么做持久化的，Redis提供的那些数据结构是怎么实现的，有哪些优缺点，何种时候用何种数据结构，Redis的协议为什么要这么设计，Redis里存储字符串是怎么存储的，和C的字符串存储方式有何差别，优劣在哪等等。
经历一家To C产品的公司，是十分有意义的。做一款To C的产品，你可以获得：
最好能把小公司和大公司都体验一遍。
接下来聊聊小公司和大公司的区别，优劣：
大公司流程真的多，通常别人都会说大公司的流程很规范，其实我认为，相比规范所带来的好处，大公司的流程带来的更多的是效率的降低。可能你一个人3天就能做完的事情，经过一大波的流程之后，通常要两周甚至更多时间才能做完，你会不断的被阻塞。
开会多不多只和管理层的想法有关。有的管理层认为多开会无益，那么整个团队就会将这种无益的东西降低到最少。反之则多，我任职的第一家公司开发不到10人，但是每天都可以开会。但是，在大公司你能遇到不开会的几率，不高。
只要你能力突出，总是能获得比同龄人更高的薪资，但是如果管理层抠门的话，前面的话作废。有的公司认为员工应该获得该有的报酬，所以他们愿意付出给员工比市场价略高的薪资。有的公司则不一样，既想马儿跑得快，又想马儿不吃草。
大公司能给你的增光，小公司做不到。除非你运气足够好，能蹭到一家爆发性增长的小公司。
Read full article from 面试的一些技巧 - Jiajun的编程随想
最近读了GFS论文，然后想自己造一个轮子出来，毕竟自己的轮子圆又圆。
最开始其实是脑子一团浆糊，没想好要怎么完成这个设计。不过仔细想了一下之后，逐步把大的系统拆解之后，然后依次实现和迭代， 最终还是成功的做出来了。
Read full article from 设计一个分布式块存储 - Jiajun的编程随想
Kotlin中的协程与Go中的协程不同，所以哪一个"更快"取决于您正在解决的问题以及您正在编写的代码类型。
一般来说，很难预先告诉哪一个人可以更好地处理您手边的问题。您必须为特定的工作负载运行基准测试。但是，这里是关键差异的一般总结，应该给你一些指导。
Kotlin协程每个简单实例所需的内存少于Go goroutines。 Kotlin中的一个简单协程只占用了几十个字节的堆内存，而Go程序以4KiB的堆栈空间开始。这意味着，如果你打算拥有数百万条协程，那么Kotlin中的协程可能会给你一个优势。它还使得Kotlin协同程序更适合于生成器和惰性序列等非常短暂的小任务。
Kotlin协同程序可以转到任何栈深度，但每个挂起函数的调用都会在堆中为其堆栈分配对象。 Kotlin协同程序中的调用堆栈当前是作为堆对象的链接列表实现的。相反，Go中的goroutines使用线性堆栈空间。这使得在Go中更高效的悬挂在深层堆栈上。因此，如果您正在编写的代码在堆栈中暂停很深，可能会发现goroutines对您更有效。
高效的异步IO是一个非常多维的设计问题。对于某种应用程序而言，高效的方法可能无法为另一种应用程序提供最佳性能。 Kotlin协同程序中的所有IO操作都是用Kotlin或Java编写的库实现的。Kotlin代码提供了各种各样的IO库。在Go中，异步IO由Go运行时使用通用Go代码不可用的基元实现。如果Go方法实现IO操作非常适合您的应用程序，那么您可能会发现它与Go运行时的紧密集成为您带来了优势。另一方面，在Kotlin中，您可以找到一个库或自己编写一个以最适合您的应用程序的方式实现异步IO的库。
Read full article from 哪个协程（goroutines和kotlin协程）更快？
solr6.4.2之webservice兼容升级 - 星火燎原智勇 - 博客园
以上这个错误对于有点经验的程序员来说都是很easy的问题，就是服务器上的jdk和咱们打包程序所使用的jdk版本不一致，很明显，本地使用的是jdk1.8而服务器上的是jdk1.7，具体可以通过命令：java -version 进行查看jdk版本。那么就好办了，直接下载或者拷贝都可以，将当前环境的jdk升级为18的即可，这个是很easy的我就不在这里啰嗦了。
Read full article from solr6.4.2之webservice兼容升级 - 星火燎原智勇 - 博客园
ArchLinux 怎么降级 package ？ - Jiajun的编程随想
今天我照常升级：pacman -Syyu。升级之后发现没法儿愉快的ssh登录了，不论是我从host登录到虚拟机，还是从虚拟机登录到 远端VPS。首先我做的事情是确认是谁的问题。
/var/log/pacman.log，发现 openssh 的确有升级，而 /etc/ssh/sshd_config 也没啥显著变化怎么愉快的降级呢？pacman会把老的包放在 /var/cache/pacman 这个文件夹下，所以直接去找就可以了：
Read full article from ArchLinux 怎么降级 package ？ - Jiajun的编程随想
上一节我们看到了每个frame的定义中都有31bit用来标识当前frame所在stream的id。那么stream是个什么鬼？stream是一个抽象概念， 因为HTTP/2把原本HTTP/1中一个请求中的头部和body打散了，分成了HEADERS和DATA两个frame。那当服务器收到一堆的frame之后，他如何 知道哪个frame和哪个frame是一起的，组合起来是一个完整的请求呢？所以我们需要stream这个抽象概念，而且由于一个HTTP/2连接可以 同时传输多个stream，所以我们可以通过下面的图片来理解stream：
Read full article from HTTP/2 简介 - Jiajun的编程随想
何谓短网址（Short URL）？顾名思义，就是形式上比较短的网址，当前主要是借助短网址来替代原先冗长的网址，方便传输和分享。短网址服务也就是将长网址转换为短网址的服务，这种服务在方便了广大网民的同时也带来了一定的安全风险。
Tencent Balde Team专门对短网址的安全问题进行过研究，也在KCON 2018上进行过分享过部分成果，本文也是对议题《短网址的攻击与防御》的解读和补充。
Read full article from 腾讯安全应急响应中心
Why Static is Bad and How to Avoid It - DZone Java
Now you can replace Utility by a mocked instance for tests, you can use a wrapped instance for logging or make it implement an interface and so one. Basically you are back in OO world. Of course you can use your favorite DI-Framework to inject the dependency (just make sure you do it properly), or if you don't mind the compile time dependency you can create an alternative constructor in the Client which uses the default implementation.
Read full article from Why Static is Bad and How to Avoid It - DZone Java
code design - Should you avoid static classes? - Stack Overflow
There are needs where you have a Utility class where all the methods are static. In that case if you make the class static it clearly indicates your intention. And at least in C# you can not have non-static methods inside a static class.
Read full article from code design - Should you avoid static classes? - Stack Overflow
What Are Special Assessment Taxes? | Finance - Zacks
When you buy a home, you typically have to pay real estate taxes to state and local governments. Real estate taxes are based on a government estimate of the value of your home. This is known as its "assessed value." A special assessment tax is an amount you must pay above and beyond your normal property taxes to pay for special projects that benefit your neighborhood. The amount you pay for special assessment taxes may be based on the assessed value of your home.
Special assessment taxes can be imposed on you for a variety of projects that involve repairs or improvement to your property. Projects that might result in special assessment taxes include sewer and water system improvements, improvements to roads and sidewalks, installation of public utilities, cleaning, landscaping and the removal of old buildings. In some cases, property owners might be able to petition the government to pursue projects that result in special assessment taxes, such as the installation of speed bumps.
The government lets homeowners deduct the cost of state and local real estate taxes on federal income tax returns. According to the Internal Revenue Service, property taxes are deductible only if they are imposed uniformly on all properties in a jurisdiction and based on the assessed value of a property. Since special assessment taxes only benefit properties in specific areas, they are usually not tax deductible. Special assessment taxes are only deductible when they are paid to fund maintenance or repairs.
Read full article from What Are Special Assessment Taxes? | Finance - Zacks
WebAIM: History of the browser user-agent string
In the beginning there was NCSA Mosaic, and Mosaic called itself NCSA_Mosaic/2.0 (Windows 3.1), and Mosaic displayed pictures along with text, and there was much rejoicing.
And behold, then came a new web browser known as "Mozilla", being short for "Mosaic Killer," but Mosaic was not amused, so the public name was changed to Netscape, and Netscape called itself Mozilla/1.0 (Win3.1), and there was more rejoicing. And Netscape supported frames, and frames became popular among the people, but Mosaic did not support frames, and so came "user agent sniffing" and to "Mozilla" webmasters sent frames, but to other browsers they sent not frames.
Read full article from WebAIM: History of the browser user-agent string
It all goes back to browser sniffing and making sure that the browsers are not blocked from getting content they can support. From the above article:
And Internet Explorer supported frames, and yet was not Mozilla, and so was not given frames. And Microsoft grew impatient, and did not wish to wait for webmasters to learn of IE and begin to send it frames, and so Internet Explorer declared that it was "Mozilla compatible" and began to impersonate Netscape, and called itself Mozilla/1.22 (compatible; MSIE 2.0; Windows 95), and Internet Explorer received frames, and all of Microsoft was happy, but webmasters were confused.
Read full article from browser - Why do Chrome and IE put "Mozilla 5.0" in the User-Agent they send to the server? - Stack Overflow
继昨天写了我的学习方法之后，没想到这么多人感慨我的学习之道，都说我自律，是我自律吗？我不这么认为，我感觉只是我稍微比别人努力一下罢了，并没有真正做到我心中的自律。
就像我认为说的特别对的一句话，就是：你只要稍微努力一下，你就超越了世界上 90% 的人了。为什么呢？因为大部分人都是得过且过，不算努力的人。很多人，感觉必须非常努力才行，以为非常努力很辛苦，所以就连一点努力都不会做了。
既然昨天写的算是我的学习之道的话，今天就来聊聊一下我作为程序员以来，总结的我的面试之道。
讲到面试，首先应该想到的是简历，简历是你能否进行面试的敲门砖。如何准备简历，如何这这个块敲门砖质量过硬，称重之强，就看你准备的如何仔细和用心了？
Read full article from 我的面试之道 - 开发者头条
书中最后总结了系统架构的二十六个原则，我摘录在这里供大家参考：
涌现原则：当各实体拼合成一个系统时，实体之间的交互会把功能、行为、性能和其他内在属性现出来。
整体原则：每个系统都作为某一个或某些个大系统的一小部分而运作，同时，每个系统中也都包含着更小的一些系统。
聚焦原则：在任何一个点上都能发现很多影响系统的问题，而其数量已经超出了人们的理解能力。因此，我们必须找出其中最关键、最重要的那些问题，并集中精力思考它们。
二元原则：所有由人类构建而成的系统，其本身都同时存在于物理领城和信息领域中。
受益原则：好的架构必须使人受益，要想把架构做好，就要专注于功能的涌现，使得系统能够把它的主要功能通过跨越系统边界的接口对外展示出来。
价值与架构原则：价值是有着一定成本的利益。架构是由形式所承载的功能。由于利益要通过功能而体现，同时形式又与成本相关，因此，这两个论述之间形成一种特别紧密的联系。
与特定解决方案无关的功能原则：糟糕的系统规范书总是把人引向预先定好的某一套具体解决方案、功能或形式中，这可能会令系统架构师的视野变窄，从而不去探素更多的潜在选项。
架构师角色原则：架构师的角色是解决歧义、专注创新，并简化复杂度。
歧义原则：系统架构的早期阶段充满了歧义。架构师必须解决这种歧义，以便给架构团队定出目标，并持续更新该目标。
现代实践压力原则：现代产品开发过程是由同时工作着的多个分布式团队来进行的，而且还有供应参与，因此，它更加需要有优秀的架构。
架构决策原则：我们要把架构决策与其他决策分开，并且要提前花一些时间来道慎地决定这些问题，因为以后如果想变更会付出很高的代价。
遗留元素复用原则：要透相地理解遗留系统及其现属性，并在新的架构中把必要的遗留元素包据进来。
产品进化原则：系统必须进化，否则就会失去竟争力。在进行架构时，应该把系统中较为稳固的部分定义为接口，以便给元素的进化提供便利。
开端原则：在产品定义的早期阶段列出的（企业内部和企业外部的）利益相关者会对架构产生极其重大的影响。
平衡原则：有很多因素会影响并作用于系统的构想、设计、实现及操作，架构师必须在这些因素中寻求一个平衡点，使大多数重要的利益相关者得到满足。
系统问题陈述原则：对问题所做的陈述会确定系统的高层目标，并划定系统的边界。就问题陈述的正确性进行反复的辩论和完善，直到你认为满意为止。
歧议与目标原则：架构师必须解决这些歧义。以便提出几条有代表性的目标并持续地更新它们。这些目标要完备且一致，要兼具挑战性和可达成性，同时又要能够为人类所解决。
创新原则：在架构中进行创新，就是要追求一种能够解决矛盾的好架构。
表面复杂度原则：我们要对系统进行分解、抽象及分层，将其表面复杂度控制在人类所能理解的范围。
必备复杂度原则：系统的必备复杂度取决于它的功能，把系统必须实现的功能仔细描述出来。然后选择一个复杂度最低的概念。
第二定律原则：系统的实际复杂度总是会超过必备复杂度。架构师要令实际复杂度尽量接近必备复杂度。
分解原则：分解是由架构师主动做出的选择。分解会影响性能的衡量标准，会影响组织的运作了式及供应商的价值捕获潜力。
二下一上原则：要想判断出对 Level1 所做的分解是否合适，必须再向下分解一层，以确定 Level2 的各种关系。
优雅原则：对于身处其中的架构师来说。如果系统的必备复杂度较低，而且其分解方式能够同与多个分解平面相匹配，那么该系统就是优雅的。
架构健壮程度原则：好的架构要能够应对各种各样的变化。能够应对变化的那种架构，要么是比较健壮架构。要么是适应能力比较强的架构。前者能够处理环境中的变化，而后者则能够适环境中的变化。
架构决策的耦合与整理原则：可以按照指标对决策的敏感度以及决策之间的连接度来排定架构决策之间的先后顺序。
Read full article from 《系统架构》读书笔记：架构到底是什么？
书中最后总结了系统架构的二十六个原则，我摘录在这里供大家参考：
涌现原则：当各实体拼合成一个系统时，实体之间的交互会把功能、行为、性能和其他内在属性现出来。
整体原则：每个系统都作为某一个或某些个大系统的一小部分而运作，同时，每个系统中也都包含着更小的一些系统。
聚焦原则：在任何一个点上都能发现很多影响系统的问题，而其数量已经超出了人们的理解能力。因此，我们必须找出其中最关键、最重要的那些问题，并集中精力思考它们。
二元原则：所有由人类构建而成的系统，其本身都同时存在于物理领城和信息领域中。
受益原则：好的架构必须使人受益，要想把架构做好，就要专注于功能的涌现，使得系统能够把它的主要功能通过跨越系统边界的接口对外展示出来。
价值与架构原则：价值是有着一定成本的利益。架构是由形式所承载的功能。由于利益要通过功能而体现，同时形式又与成本相关，因此，这两个论述之间形成一种特别紧密的联系。
与特定解决方案无关的功能原则：糟糕的系统规范书总是把人引向预先定好的某一套具体解决方案、功能或形式中，这可能会令系统架构师的视野变窄，从而不去探素更多的潜在选项。
架构师角色原则：架构师的角色是解决歧义、专注创新，并简化复杂度。
歧义原则：系统架构的早期阶段充满了歧义。架构师必须解决这种歧义，以便给架构团队定出目标，并持续更新该目标。
现代实践压力原则：现代产品开发过程是由同时工作着的多个分布式团队来进行的，而且还有供应参与，因此，它更加需要有优秀的架构。
架构决策原则：我们要把架构决策与其他决策分开，并且要提前花一些时间来道慎地决定这些问题，因为以后如果想变更会付出很高的代价。
遗留元素复用原则：要透相地理解遗留系统及其现属性，并在新的架构中把必要的遗留元素包据进来。
产品进化原则：系统必须进化，否则就会失去竟争力。在进行架构时，应该把系统中较为稳固的部分定义为接口，以便给元素的进化提供便利。
开端原则：在产品定义的早期阶段列出的（企业内部和企业外部的）利益相关者会对架构产生极其重大的影响。
平衡原则：有很多因素会影响并作用于系统的构想、设计、实现及操作，架构师必须在这些因素中寻求一个平衡点，使大多数重要的利益相关者得到满足。
系统问题陈述原则：对问题所做的陈述会确定系统的高层目标，并划定系统的边界。就问题陈述的正确性进行反复的辩论和完善，直到你认为满意为止。
歧议与目标原则：架构师必须解决这些歧义。以便提出几条有代表性的目标并持续地更新它们。这些目标要完备且一致，要兼具挑战性和可达成性，同时又要能够为人类所解决。
创新原则：在架构中进行创新，就是要追求一种能够解决矛盾的好架构。
表面复杂度原则：我们要对系统进行分解、抽象及分层，将其表面复杂度控制在人类所能理解的范围。
必备复杂度原则：系统的必备复杂度取决于它的功能，把系统必须实现的功能仔细描述出来。然后选择一个复杂度最低的概念。
第二定律原则：系统的实际复杂度总是会超过必备复杂度。架构师要令实际复杂度尽量接近必备复杂度。
分解原则：分解是由架构师主动做出的选择。分解会影响性能的衡量标准，会影响组织的运作了式及供应商的价值捕获潜力。
二下一上原则：要想判断出对 Level1 所做的分解是否合适，必须再向下分解一层，以确定 Level2 的各种关系。
优雅原则：对于身处其中的架构师来说。如果系统的必备复杂度较低，而且其分解方式能够同与多个分解平面相匹配，那么该系统就是优雅的。
架构健壮程度原则：好的架构要能够应对各种各样的变化。能够应对变化的那种架构，要么是比较健壮架构。要么是适应能力比较强的架构。前者能够处理环境中的变化，而后者则能够适环境中的变化。
架构决策的耦合与整理原则：可以按照指标对决策的敏感度以及决策之间的连接度来排定架构决策之间的先后顺序。
Read full article from 杏仁技术站
Tracing Request IDs — Brandur Leach
A very lightweight alternative to something like Twitter's Zipkin, and based on the same ideas as the troubleshooting technique that Amazon uses for route 53, request IDs are a way of grouping all the information associated with a given request, even as that request makes its way across a distributed architecture. The benefits are two-fold:
Read full article from Tracing Request IDs — Brandur Leach
Javers Vs Envers Comparision — JaVers Blog
In the Java world, there are two tools for data auditing: Envers and JaVers. Envers is here for a long time and it's considered mainstream. JaVers offers the fresh approach and technology independence. If you consider which tool will be better for your project, this article is the good starting point.
Read full article from Javers Vs Envers Comparision — JaVers Blog
sbc(七)分布式限流 | crossoverJie's Blog
本文接着上文应用限流进行讨论。
之前谈到的限流方案只能针对于单个 JVM 有效，也就是单机应用。而对于现在普遍的分布式应用也得有一个分布式限流的方案。
Read full article from sbc(七)分布式限流 | crossoverJie's Blog
强如 Disruptor 也发生内存溢出？ | crossoverJie's Blog
OutOfMemoryError 问题相信很多朋友都遇到过，相对于常见的业务异常（数组越界、空指针等）来说这类问题是很难定位和解决的。
本文以最近碰到的一次线上内存溢出的定位、解决问题的方式展开；希望能对碰到类似问题的同学带来思路和帮助。
主要从表现-->排查-->定位-->解决 四个步骤来分析和解决问题。
最近我们生产上的一个应用不断的爆出内存溢出，并且随着业务量的增长出现的频次越来越高。
Read full article from 强如 Disruptor 也发生内存溢出？ | crossoverJie's Blog
Eclipse has a mechanism called access restrictions to prevent you from accidentally using classes which Eclipse thinks are not part of the public API. Usually, Eclipse is right about that, in both senses: We usually do not want to use something which is not part of the public API. And Eclipse is usually right about what is and what isn't part of the public API.
Now, there can be situations, where you want to use public Non-API, like sun.misc (you shouldn't, unless you know what you're doing). And there can be situations, where Eclipse is not really right (that's what happened to me, I just wanted to use javax.smartcardio). In that case, we get this error in Eclipse.
Read full article from java - Access restriction: The type 'Application' is not API (restriction on required library rt.jar) - Stack Overflow
Programmatically Taking Heap and Thread Dumps in HotSpot
While taking heap and thread dumps are one click away using modern JVM toolset, in many cases the deployment environment access restrictions render these options unusable. Hence, you might end up exposing these functionalities in certain ways like an internal REST interface. This implies a new nasty obstacle: You need to know how to programmatically take heap and thread dumps in a Java application. Unfortunately, there does not exist a standard interface to access these functionalities within the VM as of date. But if you are only concerned about HotSpot, then you are in luck!
Read full article from Programmatically Taking Heap and Thread Dumps in HotSpot
Monitor and diagnose performance in Java SE 6
Java SE 5 introduced the java.util.concurrent.locks package, which provides a framework for lock and wait conditions. This framework is distinct from Java's built-in synchronization support and allows greater flexibility in the use of locks.
Java SE 6 adds support for java.util.concurrent.locks in the java.lang.management package. This includes new classes that provide information about locks, as well as enhancements to the ThreadInfo, ThreadMXBean, and OperatingSystemMXBean interfaces.
Read full article from Monitor and diagnose performance in Java SE 6
The generic (non–Message Queue) way of obtaining a JMX connector, as described in the JMX Specification, is by invoking the static connect method of the standard JMX class JMXConnectorFactory (see Example 2–3). Client applications may choose to use this method instead of an administration connection factory in order to avoid dependency on Message Queue–specific classes.
Read full article from Obtaining a JMX Connector Without Using an Administration Connection Factory (Sun Java System Message Queue 4.1 Developer's Guide for JMX Clients)
Monitoring and Management Using JMX Technology - Java SE Monitoring and Management Guide
The Java virtual machine (Java VM ) has built-in instrumentation that enables you to monitor and manage it using the Java Management Extensions (JMX) technology. These built-in management utilities are often referred to as out-of-the-box management tools for the Java VM. You can also monitor any appropriately instrumented applications using the JMX API.
To enable and configure the out-of-the-box JMX agent so that it can monitor and manage the Java VM, you must set certain system properties when you start the Java VM. You set a system property on the command-line as follows.
java -Dproperty=value ...
You can set any number of system properties in this way. If you do not specify a value for a management property, then the property is set with its default value. The full set of out-of-the-box management properties is described in Table 2-1 at the end of this chapter. You can also set system properties in a configuration file, as described in Out-of-the-Box Monitoring and Management Properties.
Read full article from Monitoring and Management Using JMX Technology - Java SE Monitoring and Management Guide
STACKOVERFLOWERROR: CAUSES & SOLUTIONS – Fast thread
There might be legitimate reason where a threads stack size needs to be increased. Maybe thread has to execute large number of methods or lot of local variables/created in the methods thread has been executing. In such circumstance, you can increase the thread's stack size using the JVM argument: '-Xss'. This argument needs to be passed when you start the application. Example:
Read full article from STACKOVERFLOWERROR: CAUSES & SOLUTIONS – Fast thread
当然，顺丰体量虽大，但毕竟并不是一家互联网公司，可能工程师数量还不及业内一家小型创业公司。在这种情况下，一人多用、权限混乱也是可以理解的常态。但对于数据十分重要、服务绝对不能停的业务，CTO和项目leader，应该对员工可能出现的操作失误设计预先防范的措施和制度，否则就是失职。当你的业务有可能因为员工一个小失误就瘫痪，甚至数据无法找回导致公司关门时，你怎么还睡得着觉？
在照顾孩子的时候，我学到的最重要的道理就是：如果有样东西不能让孩子玩，那就不能放在孩子够得着的地方。 如果你是一名销售，刚签完一个大客户，兴高采烈地回到家里，把合同扔到茶几上，然后冲进洗手间上了个厕所回来，就发现合同被你家熊孩子用笔涂得一塌糊涂，你觉得是该怪孩子调皮呢，还是该怪你自己不小心？
Read full article from 镓话
1、可以镜像保存整个目录树和文件系统。
2、可以很容易做到保持原来文件的权限、时间、软硬链接等等。
3、无须特殊权限即可安装。
4、快速：第一次同步时rsync会复制全部内容，但在下一次只传输修改过的文件。rsync在传输数据的过程中可以实行压缩及解压缩操作，因此可以使用更少的带宽。
rsync可以通过rsh或ssh，也能以daemon模式去运行，在以daemon方式运行时rsync server会打开一个873端口，等待客户端去连接。连接时，rsync server会检查口令是否相符，若通过口令查核，则可以开始进行文件传输。第一次连通完成时，会把整份文件传输一次，以后则就只需进行增量备份。
Read full article from 小米运维
NATS是一个开源、轻量级、高性能的云原生消息系统。它是实现了具有更高级别扩展性的发布-订阅消息系统。即使NATS是基于发布-订阅分发模型，你同样可以通过订阅服务器队列组实现分布式系统。NATS创建于2010年，原是服务于Cloud Foundary平台的消息系统。NATS最开始是由Ruby语言实现的，但随后NATS团队使用Go语言进行了重写。
NATS在两个互相操作的模块中使用：核心NATS平台-NATS服务器（其可执行文件的名字为gnatsd）简称为NATS；NATS流（其可执行文件的名字为nats-streaming-server）是一个事件流服务，用于NATS添加事件流、发布保障及再现历史数据。NATS服务器是面向高性能现代分布式系统架构而设计的，并不能进行消息持久化。因此，如果你的系统是离线状态，将不会接收到消息。如果你想要实现持续消息传递和发布保障，可以使用NATS流代替核心NATS平台，NATS流建立在核心NATS平台基础之上。本文我将专注于基础的NATS服务器的介绍，至于NATS流我将在后续的文章中介绍。
NATS服务器（gnatsd）是最高性能的分布式消息系统，可以达到每秒钟发送1.5千万-1.8千万条消息。NATS平台易于使用和扩展，NATS的简洁性和高性能性质使得它对于构建现代云原生分布式系统及微服务而言是个不错的选择。我过去使用过许多消息系统，因为NATS的性能和简洁性，所以我强烈推荐它。
Read full article from 容器时代
上面提到了「技术能力」并不等于「编码能力」，抛开一些非核心能力的话，可以简单点理解为「技术能力」=「编码能力」+「技术评估能力」。当我们还是程序员的时候编码能力是我们最为注重的，但当我们转技术管理之后，技术评估能力就应该成为我们的重点，编码能力在精力有限的情况下是可以放弃的。
技术评估能力主要是指我们通过自己的技术认知，去评估一个项目/开发任务 要不要做、值不得值得做、做到什么程度，技术方案边界在哪儿、技术选型用什么、可用性/拓展性方案是什么等等，甚至是对团队人员技术水平的边界评估。
怎样才能保持技术评估能力，以及怎样能不断增长自己的技术评估水平呢？作为技术管理者而言，很明显，已经不能通过大量编码的方式去提高技术能力了，只能依赖于：自己以往技术经验的积累、团队的技术分享、技术调研、与同行专家交流、培训学习等方式。这些方式有的时候会比编码的方式更快更有效率。
Read full article from 不止思考
Solr's DateRangeField, How Does It Perform?
I have to credit David Smiley as co-author here. First of all, he's largely responsible for the spatial functionality and second he's been very generous explaining some details here. Mistakes are my responsibility of course. Solr has had a new DateRangeField for quite some time (since 5.0, see SOLR-6103. DateRangeFields are based on more of the magic of Solr Spatial and allow some very interesting ways of working with dates. Here are a couple of references to get you started. Working with dates, Solr Reference Guide Spatial for Time Durations
q=field:[2000-11-01 TO 2014-12-01] or q=field:2000-11date range in a single field. For instance a field in a document could be added to a document in SolrJ as solrInputDocument.addField("dateRange", "[2000 TO 2014-05-21]") or in an XML format as <field name="dateRange">[2000 TO 2014-05-21]</field>q=date_e:[* TO target] AND date_s:[target TO *]. This worked fine if the document only had one range, but when two or more ranges were necessary, this approach falls down since if date_s and date_e have multiValued="true", the query above would find the doc if any entry in date_s was < than target date and any date_e was > the target date..Read full article from Solr's DateRangeField, How Does It Perform?
Working with Dates | Apache Solr Reference Guide 6.6
DateRangeField is almost a drop-in replacement for places where TrieDateField is used. The only difference is that Solr's XML or SolrJ response formats will expose the stored data as a String instead of a Date. The underlying index data for this field will be a bit larger. Queries that align to units of time a second on up should be faster than TrieDateField, especially if it's in UTC. But the main point of DateRangeField as its name suggests is to allow indexing date ranges. To do that, simply supply strings in the format shown above. It also supports specifying 3 different relational predicates between the indexed data, and the query range: Intersects (default), Contains, Within. You can specify the predicate by querying using the op local-params parameter like so:
Read full article from Working with Dates | Apache Solr Reference Guide 6.6
I would like to share my resolution here for anyone else struggling with this. My requirement was to get all restaurants open now. The caveat was that each restaurant could have multiple opening hours in a single day. And opening hours for each day could vary. Added date_range field into schema.xml: <field name="openingHours" type="date_range" indexed="true" stored="true" multiValued="true" /> <fieldType name="date_range" class="solr.DateRangeField"/> Indexed each opening hour for the next week as dates, NOTE! convert your time zones to UTC before indexing openingHours": [
Now the fun part starts, to get opening hour ranges, which are not dependent on the actual opening hours of any restaurant I passed in the following: facet.range=openingHours&f.openingHours.facet.range.start=NOW&f.openingHours.facet.range.end=NOW%2B6HOUR&f.openingHours.facet.range.gap=%2B1HOUR facet.range : specifies your facet on which you want to range one f.openingHours.facet.range.start : the time from when the ranges should start - i specified now as i would want to get all restaurants open from now. f.openingHours.facet.range.end : the time when the range should stop, let say i want to range between all restaurants open from now till tonights evening f.openingHours.facet.range.gap : this specifies the gaps in the range (start to end) so if your range is for 12 hours, you can have a gap of 1 Hour, so you will get 12 points in time to range on Now to actually query on these ranges you need to pass the following to fq parameter {!field f=openingHours op=Contains}[2016-02-02T14:50 TO 2016-02-02T15:00] what the above seas is that you want to query your openingHours to see whether any restaurant is open from 2016-02-02T14:50 TO 2016-02-02T15:00
Read full article from DateRangeField - Solr Wiki
The Intrinsic Static Site — Brandur Leach
In short, we now have a set of static assets in S3 that are distributed around the globe by CloudFront, TLS termination with an evergreen certificate, nearly unlimited scalability, and a deployment process based on pull requests that's so easy that within five years you'll probably have forgotten how it works. And despite all of this, unless you're running a hugely successful site, costs will probably run in the low single digits of dollars a month (or less).
Read full article from The Intrinsic Static Site — Brandur Leach
Using Canonical Log Lines for Online Visibility — Brandur Leach
Over the next few weeks I want to post a few articles about some of my favorite operational tricks that I've seen while working at Stripe.
The first, and easily my favorite, is the canonical log line. It's a lightweight pattern for improved visibility into services and acts as a middle ground between other types of analytics in that it's a good trade-off between ease of access and flexibility.
Read full article from Using Canonical Log Lines for Online Visibility — Brandur Leach
Using Atomic Transactions to Power an Idempotent API — Brandur Leach
What we've covered here works nicely for HTTP requests that are idempotent. That's probably a healthy majority given a well-designed API, but there are always going to be some endpoints that are not idempotent. Examples include calling out to an external payment gateway with a credit card, requesting a server to be provisioned, or anything else that needs to make a synchronous network request.
For these types of requests we're going to need to build something a little more sophisticated, but just like in this simpler case, our database has us covered. In part two of this series we'll look at how to implement idempotency keys on top of multi-stage transactions.
Read full article from Using Atomic Transactions to Power an Idempotent API — Brandur Leach
Distributed transactions in Spring, with and without XA | JavaWorld
While it's common to use the Java Transaction API and the XA protocol for distributed transactions in Spring, you do have other options. The optimum implementation depends on the types of resources your application uses and the trade-offs you're willing to make between performance, safety, reliability, and data integrity. In this JavaWorld feature, SpringSource's David Syer guides you through seven patterns for distributed transactions in Spring applications, three of them with XA and four without. Level: Intermediate
The Spring Framework's support for the Java Transaction API (JTA) enables applications to use distributed transactions and the XA protocol without running in a Java EE container. Even with this support, however, XA is expensive and can be unreliable or cumbersome to administrate. It may come as a welcome surprise, then, that a certain class of applications can avoid the use of XA altogether.
To help you understand the considerations involved in various approaches to distributed transactions, I'll analyze seven transaction-processing patterns, providing code samples to make them concrete. I'll present the patterns in reverse order of safety or reliability, starting with those with the highest guarantee of data integrity and atomicity under the most general circumstances. As you move down the list, more caveats and limitations will apply. The patterns are also roughly in reverse order of runtime cost (starting with the most expensive). The patterns are all architectural, or technical, as opposed to business patterns, so I don't focus on the business use case, only on the minimal amount of code to see each pattern working.
Read full article from Distributed transactions in Spring, with and without XA | JavaWorld
If kafak transaction fails unable to rollback DB · Issue #489 · spring-projects/spring-kafka
If DB transaction is failing than Kafka Transaction is getting aborted.
But if Kafka Transaction is failing scenario is simulated, than DB transaction is not rolled back and Kafka transaction is trying to commit for unsuccessful send of message (which should be trying to ABORT - NOT COMMIT).
I simulated Kafka error org.apache.kafka.common.errors.TimeoutException by deleting topic.
Read full article from If kafak transaction fails unable to rollback DB · Issue #489 · spring-projects/spring-kafka
I joined LinkedIn about six years ago at a particularly interesting time. We were just beginning to run up against the limits of our monolithic, centralized database and needed to start the transition to a portfolio of specialized distributed systems. This has been an interesting experience: we built, deployed, and run to this day a distributed graph database, a distributed search backend, a Hadoop installation, and a first and second generation key-value store.
One of the most useful things I learned in all this was that many of the things we were building had a very simple concept at their heart: the log. Sometimes called write-ahead logs or commit logs or transaction logs, logs have been around almost as long as computers and are at the heart of many distributed data systems and real-time application architectures.
Read full article from The Log: What every software engineer should know about real-time data's unifying abstraction | LinkedIn Engineering
你应该雇佣老程序员，我没开玩笑！当然，年长的程序员不会像大学毕业生那样能够工作那么多个小时。他们有孩子和配偶，要还抵押贷款，而且还要参加垒球比赛。他们不会在办公室通宵玩 XBox 和乒乓球，也不会每周工作 80 个小时，实际上他们将会享受属于他们的假期时间。当然相比年轻程序员，他们的薪资待遇更高。尽管你有这么多理由不去雇佣老程序员，但你别无选择。最简单的一个原因是：他们值得你的付出。我知道这一点，我就是这样一名老程序员。
老程序员也许不会像 25 岁时那样在大脑中能装下那么多代码，但我们有着非常丰富的经验。我们知道，不管你的脑袋有多大，每个系统的代码规模都将会变得远远超过你大脑中所能容纳的量，所以大脑能装下多少代码并没有你想象的那么重要。相反，我们理解模块化的设计思想，我们是传说中的 10X 程序员，当然不是因为我们写的代码比其他人好得多，而是因为我们已经经历过了一切。在过去这些年，我们已经使用过很多编程语言，因此我们可以很容易学会任何新的语言。我们知道语言间的共同点，编程语言的概念一次又一次兴起，拥有着多年的经验，我们可以发现语言的相似之处并指出差异的地方。
Read full article from ASCE1885
A Comparison of Advanced, Modern Cloud Databases — Brandur Leach
Opinion time: the best choice for most people will be to start with Postgres. It's a battle-tested database with a spectacular number of features and few limitations. It's open source and widely available so it can easily be run in development, CI, or migrated across every major cloud provider. Vertical scaling will go a long way for organizations who curate their data and offload lower fidelity information to more scalable stores.
After you're at the scale of AirBnB or Uber, something like Aurora should look interesting. It seems to have many of the advantages of Postgres, and yet still manages to maintain data locality and scalable storage (at the costs of loss of dev/production parity and vendor lock in). Organizations at this tier who run hot and need compute and memory resources that are scalable beyond a single node might benefit from something like Citus instead.
After you're at the scale of Google, something closer to Spanner is probably the right answer. Although less suitable for low latency operations, its scalability appears to be practically limitless.
Read full article from A Comparison of Advanced, Modern Cloud Databases — Brandur Leach
On-demand publishing is used to provide readers with fresh information, as well as to customize publications for different user profiles. When customized on-demand publishing is taken to the extreme, each customer receives an individually designed edition of the publication. In practice, this degree of customization can only be achieved when the publication process is nearly automatic. Currently, the part of the process that most readily may be automated is the pagination. As a multitude of tools and standards for publishing on the electronic media have emerged in recent years, automatic pagination has become an interesting option for a variety of situations.
Automatic pagination may be useful anywhere where pagination is considered useful but too expensive or too slow by traditional means. The presence of the following factors might therefore suggest using an application carrying out automatic pagination:
Read full article from Automatic pagination
Your software needs to leverage multiple cores, handle thousands of users and terabytes of data, and continue working in the face of both hardware and software failure. Concurrency and parallelism are the keys, and Seven Concurrency Models in Seven Weeks equips you for this new world. See how emerging technologies such as actors and functional programming address issues with traditional threads and locks development. Learn how to exploit the parallelism in your computer's GPU and leverage clusters of machines with MapReduce and Stream Processing. And do it all with the confidence that comes from using tools that help you write crystal clear, high-quality code.
Read full article from Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher | The Pragmatic Bookshelf