Erlang如何与C++通信?
同问通信和语言有什么关系?你究竟是想问 IPC 呢,还是想问跨语言调用呢?讲清楚了才好答你啊。
同问通信和语言有什么关系?你究竟是想问 IPC 呢,还是想问跨语言调用呢?讲清楚了才好答你啊。
前端负责和用户交互,后端负责和计算机交互
更新一下,看到 @wakao 的答案,槽点有些多,吐槽下:
==== 以下为原回答 ====
谢邀。
之前一直是用 JakeWharton/butterknife · GitHub 加上 avast/android-butterknife-zelezny · GitHub ,你确定你手写 findViewById 会比我用 Plugin 一键生成代码更快?:)
使用 ButterKnife,是因为它足够轻。
Field and method binding for Android views which uses annotation processing to generate boilerplate code for you.
通过注解,把 findViewById 代码的生成丢给编译器处理,在不降低执行效率的前提下,提高代码可读性和减少代码量,有什么理由不用?至于 AndroidAnnotations,没用过,也不推荐用,太重,看着恶心。
BaaS 开始当道的年头,题主不是更应该担心后端的未来么?:)
安利一下我大
!上面都是搞 GE、Shader 和算法的大神们!



对显卡性能有信心的可以点开上面的链接测试 fps :)
里面很多还是可以转化为产品的(OpenGL,WebGL,OpenGL ES)
例如上面这个我把它移植到 OpenGL ES 了

谢邀。一个比较不错的解决方案:
chrisjenx/Calligraphy · GitHub
Custom font in Styles
<style name="TextViewCustomFont"> <item name="fontPath">fonts/RobotoCondensed-Regular.ttf</item> </style>Custom font defined in Theme
<style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar"> <item name="android:textViewStyle">@style/AppTheme.Widget.TextView</item> </style> <style name="AppTheme.Widget"/> <style name="AppTheme.Widget.TextView" parent="android:Widget.Holo.Light.TextView"> <item name="fontPath">fonts/Roboto-ThinItalic.ttf</item> </style>
上面的 Styles 配置,可以方便地把应用内所有 TextView 的字体配置为「Roboto-ThinItalic」(需要字体文件支持)。但是需要对 Activity 做一些 Wrap:
@Override protected void attachBaseContext(Context newBase) { super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase)); }
谢邀。支持接入微信公众号,转换公众号接受的消息为弹幕:
Wechat integration
出生时家里就有电脑了,老爸是做电脑培训的(教五笔、教 WPS/OFFICE、教 Visual FoxPro),他偶尔也接一些小企业的项目,用 Visual FoxPro 写一些企业管理软件。而我呢,从小就被他影响,只要是电脑相关的事物都很感兴趣(大概我在小学一年纪时,老爸就在尝试教我 Foxbase 了,然并卵,学不会 ╮(╯▽╰)╭)。最早的时候,店里的电脑(有两排)装的都是 DOS,老爸把电脑都用一种奇怪的线缆连接起来,然后一台主机每天在运行一个程序,整个屏幕没有文字,只有像贪吃蛇一样的粗线条在屏幕上不断移动(有谁知道是什么的话私信一下我)。
记得当初最早玩的游戏是 DOS 下的「波斯王子」(小学之前),每次要玩的时候都在 DOS 下输命令,可是那时候我还小,只能每次要玩的时候就叫老爸,让他来帮忙打开游戏:

玩过了很多关卡,可是始终没有玩到结局,记得有一些关于剧情的动画,一个巫师一个女主,具体是怎样真的想不起来了,只觉得很多关卡真的很难玩。。
那个时候店里的学员很多都是来学打字的,家里的电脑都装了五笔速成等练字软体,也有一些打字游戏,具体真记不起来了:

那时候我妈在店里帮忙培训,她是教五笔的,她打字也可快了,一分钟四五十个字的速度吧!也教 WPS(DOS 时期的 WPS),她整天让我背五笔的键盘表,可是我一直背不出来,所以也不会打中文,心智没到达那个程度啊。。
上了小学后,老爸培训班里就有一电脑排装上了 Windows95 了!刚接触到 GUI OS 和鼠标的我,仿佛发现了新大陆。DOS 对我来说实在是无法操纵,基本就在玩几个打字游戏。但是 Windows 的 GUI 就不同了,什么都可以捣鼓一下,那时候 Windows 下很多应用的图标都像下面这种:

很多图表看上去很像游戏图标好伐!!!所以我都喜欢点一下,看看有什么出来。
在那个时代做得最多的应该就是玩游戏了,至今仍然记得的有下面这些:

这真的是我到现在还能清晰记住剧情和 BGM 的 RPG GAME,再后来玩过很多游戏,都很难超越它在我心目中的地位了,无论是剧情、画风、BGM 都代表了当时国产游戏的最高境界,现在这么用心做游戏的商家真的很少了。幸好当初老爸买的是正版 :) 无憾。

这个游戏超耐玩的好不!!!玩了很久,通了很多管,但也不知道结局是如何。只记得前期招田伯光入队很吊好不,还有就是可以开个船到处游荡,有沙漠,有各种山洞,还有一个泥潭迷阵过了超久。。。
当时真的玩过很多游戏,不过记不住了,其他一些游戏是比较后玩的(Windows ME 以后)所以就不写了,先占坑记起来再写。
现在想想,当初家里有电脑真的对我影响超大,虽然并没有成为能和同伴交流的谈资(大多数同龄人家里都没有电脑,而且大概到我五六年级时网吧才开始流行),但是它真的成为了我童年记忆很重要的一部分,除去正常校园生活外,最期待的就是打开电脑的那一刻。所以很感谢我的老爸以及老爸的电脑们,让我这个智商并不高的儿子在未来很多年后对于电脑的热爱以及了解都远超很多人。这大概就是所谓的「起跑线」吧。
谢邀。
貌似国际友人都更推荐谷歌亲儿子系列 Nexus (5),主要原因是它的屏幕大小比较接近目前主流屏幕的平均水平,而且通常 Google 最先对它开放最新的 Android OS。
如果题主只考虑国内机子的话,还是买小米吧。
泻药 @Dennis Yang,能力有限,随便答答。
写出实用或能用的代码并不难,但是很难写出好的代码。架构师和工程师之间的区别在于,工程师更关注实现的结果,而架构师关注实现的过程。
当然,并没有纯的意义上架构师和工程师之间的区别,架构师本身也是由工程师分化而来。当编码达到一定经验时,都会开始关注结果以外的东西,会发现任何东西都可以抽象、分层、解耦、整合,会开始关注「架构」层面上的东西,毕竟他们也写够烂的代码了。
你们啊,老想着做什么架构师,多积累点经验、多点反思、多点沉淀啊。
IBM 对 PaaS 的研究衍生的产品,简单来说就是 Runtime Core 的组件化,然后再通过这些 通用组件 去组合成不同 Langue 的 Runtime,当然不限于已有的 Langue(包括 Ruby),也可以用这些组件去创建新的 Langue Runtime。
With common runtime components, everyone (including IBM) can all better leverage our efforts to make runtimes better, faster, more capable, and more integrated to accelerate bringing not just the promise of cloud computing but also the reality that developers should expect from a cloud computing environment.
有可能提高 Ruby 脚本的运行速度?这个待项目开源出来后才可鉴定。
混淆是无法混淆代码中的字符串的,所以混淆并不能防止 URL 接口地址泄露。其次,URL 接口地址泄露是无可避免的,抓下包就知道地址了,不需要反编译。
另外,题主你的目的有问题,不应该是如何隐藏接口地址,而应该是如何提高接口安全(例如如何避免接口通讯内容被泄露),根据我多次抓包以及反编译国内一些比较出名 APP 的经验,总结出以下几点能提高接口安全的方法:
记得 Bilibili 和 虾米音乐 都是使用 HTTPS 与服务端进行通讯的。
而如果题主真的连 URL 路由(理解为接口的 Action)都要隐藏的话,有两种做法:

谢邀。凡是教材,里面肯定都有可取之处,但是看比较旧的教材,肯定会额外多花一些知识更新的成本,所以最好还是换个比较新的教材来学习。
看有人拿 XML 和 JSON 做比较,顺便补一点:
XML 是「文档标记语言」,而 JSON 是「数据交互语言」,XML 比起 JSON 描述能力要强,所以在描述复杂文档的时候会选用 XML(例如 Layout 文件)。但是 JSON 比 XML 更为 Human readable、更易编写,也对机器更为友好,所以用 JSON 来储存一些简单的配置是比 XML 要好用得多的(例如大家都知道的 Shadowsocks 就是使用 JSON 进行应用配置)。但是 JSON 天生描述能力不强,它擅长的是描述数据,而非文档(配置其实也是文档的一种),所以稍微复杂的文档是不会使用 JSON 来描述,这也就是为什么会衍生出 YAML、TOML 一类语言的原因(拒绝拥抱 XML 的后果)。
===
SharedPreferences 是一整套东西啊,PreferencesActivity 也依赖于它。所以对实现 APP 偏好设置来说,它就是「最方便的实现」,你不用关心它底层是用数据结构去储存的,只是 Android 选择用 XML 去描述而已。
而 SQLite 是关系数据库,数据间有较复杂关系的,操作需要用到复杂的增删改查,无疑使用 SQLite 是最好的方案。
而题主说的一些轻量的数据,确实是持久化为文件更方便。如果是储存 用户偏好设置 还是用 SharedPreferences 来解决方便多了,无需接触到数据格式。如果并非面向用户,而是面向应用或面向开发者的话(例如一些 应用配置、常用数据),JSON 是不错的选择,毕竟 JSON 比起 XML 来说更易阅读与调试。
当然 JSON 也不是唯一选择,应用配置的话用 YAML 或 TOML 更好(更强的描述能力,更少冗余),只不过 JSON 应用更广泛罢了。
android - public static variable or use putExtra method of intent class
使用静态变量在 Android 里是不被推荐的(移动端相对 PC 端来说对内存的限制更为严格)。一方面你必须保证每次使用完都将其赋值为 null 来使它被正常回收。另一方面你又要保证它不持有 Android 组件的实例,否则会造成内存泄露。
而 Intent 机制是用于处理 Android 中组件间通讯以及互相调用的,使用 Intent 在 Activity 间传递数据是最优解。
说实话,有点后劲不足。
豆瓣态度也很明确了,这仅仅是个「能用的轮子」,并非代码托管的最佳实践,但它也有一些可取之处:
用 Python 写的;
一些豆瓣本地化的东西。
题主说的其实就是 C/S 架构层面的东西,也早就不新奇了,大多数的 C/S 架构产品的通信加密协议复杂多了。要知道「Browser」区别于传统的「Client」的地方在于它没有指定且唯一的「Server」,而且是通过 开放协议(HTTP/HTTPS)访问服务端。
而题主所说的「闭源浏览器」,先不说通信协议闭源,服务端如果不开放出去的话,基本上就是完全的 C/S 架构了,自己公司玩玩可以,就算 Server 端开放出去,闭源的话也很难吸引到开发者,因为对开发者来说,Server 端被垄断且无法定制,机制不透明导致的 BUG 也无法修复。
其实题主会有这样的想法很正常,为什么 Browser 将源码直接对用户开放呢,为什么不加密传输呢?其实,HTTP 可以 gzip 压缩,HTTPS 协议更是只有 Browser 才能解密传输数据,所以事实上是「Browser 提供给用户查看源码的功能」,究其原因,我觉得第一是方便开发者调试,第二是加密措施基本上防不胜防,开发者成千上亿,有一人逆向出来基本上就废了,第三应该就是历史原因了:HTML 文件在早期就是简单地描述页面数据、元素,是解释性语言,并非编译型语言。
正好前几天在开发 Intellij IDEA(/Android Studio)的插件,官方教程可参考:
IntelliJ IDEA 15.0 Help :: Plugin Development Guidelines
我是在 Intellij IDEA 的社区版(免费版)上进行开发的,项目在这里:
nekocode/android-parcelable-intellij-plugin-kotlin · GitHub
。开发完的 Plugin 可以上传到 Jetbrains 的 Plugin Repository 上:
在 Github 上有很多开源的 Intellij 插件,也可以翻看下,有很大的教学作用~
mcharmas/android-parcelable-intellij-plugin · GitHub inmite/android-selector-chapek · GitHub
来填坑了~
你们确定用对了 Fragment 了么?:) 居然还有说 Fragment 失去出现意义的,请先弄明白 Fragment 出现的意义是什么好不。
Fragment 的出现一方面是为了缓解 Activity 任务过重的问题,另一方面是为了处理在不同屏幕上 UI 组件的布局问题,而且它还提供了一些新的特性(例如 Retainable)来处理一些在 Activity 中比较棘手的问题。
其实从 Google 推出 Support 包来支持在早些版本实现 Fragment 这一行为就可以看出,谷歌认为 Fragment 比 Activity 更适合管理屏幕组件,因为 Activity 在单屏下无法细分,注定了如果使用 Activity 来管理页面所有 UI 组件的话会造成组件耦合以及不可复用,代码也臃肿地会令人头痛。总而言之,我认为使用 Fragment 绝对是一种好习惯。
4 reasons to use Android Fragments
,这篇文章解释了在四个地方应该使用 Fragments。
另附 Fragment 的正确用法,遇到坑的都可以去好好理解下:
可以参考下这个问题 java - Should private helper methods be static if they can be static ,总结来说有以下两点:
把 JIT 的内联优化放在第二位是因为这是个很小的优化,而Volley 源码中大量使用的 private static 主要原因是,为了清晰地表明该方法不会对所在对象造成任何更改。
公共漏洞可以在 http://www.cvedetails.com/ 中查找。
可以搜索到,在 Windows 7 SP1 下,与 Image 相关的漏洞有以下几个:
它们都允许通过制造特殊的图片文件,来进行远程攻击。(前提是未打相应补丁)
视频文件同理,有兴趣的可以自己上去找找。
谢邀,题主最好贴下后台实现上传的代码。=_=
iOS 端可以尝试下以 multipart/form-data 方式上传,很多后台都是用 multipart/form-data 的方式支持多文件上传的。
它在本地开了个后台 Http 服务器,用于监听本地(或外部)的 Http 请求。
这有一个很流氓的用处,就是只要 WebView 对本地 Http 服务器发个 Ajax 请求,就可以让百度 SDK 做些 Native 操作(启动,安装应用等)。
发散一下思维,这样就可以在微信内部浏览器打开外部应用了。例如知乎 APP 只要在本地开个 Http 服务器监听 Ajax 请求,然后知乎网页版往 localhost 发一条 Ajax 请求,本地 Http 服务器接受到 Ajax 请求就打开 APP 客户端,这样就可以实现微信内部浏览器(或其他 WebView)跳转到知乎 APP 客户端了。。
这样子来修改 View 的属性
textView.text = "hello"
这样子来处理事件
override fun onTouch(v: View, event: MotionEvent): Boolean {
when (event.action) {
MotionEvent.ACTION_DOWN -> showToast("ACTION_DOWN ")
MotionEvent.ACTION_MOVE -> showToast("ACTION_MOVE ")
}
return true
}
这样子来使用 intent
val intent = intentFor<OtherActivity>(
"model" to Model(5, 0),
"str" to "xxx"
)
intent.singleTop()
startActivity(intent)
仅仅几行代码就定义了一个拥有单个 Fragment 的 Activity
public class MainActivity : SingleFragmentActivity() {
override val fragmentClass = TestFragment::class.java
override val fragmentBundle = {
null
}
}
这样子来储存本地数据(持久化)
Storage["test"] = Model(5, 1)

使用 JitPack 来编译你 Github 上的 lib项目并分享出去
使用 square/leakcanary · GitHub 来检测内存泄露
使用mmin18/LayoutCast · GitHub 来实现增量编译,提高编译速度(Android Studio 2.0 Preview 已经支持 Instant Run )
使用 iptables 截获连接到本热点的手机的请求报文(http,https,dns)并选择性进行转发。这里的用处就是可以实现各种页面劫持,例如可以提供一个登录网页,连接到该热点的用户必须要登录后才可以继续使用网络。
安卓App热补丁动态修复技术介绍 - MAGI的专栏 - 知乎专栏
mmin18/AndroidDynamicLoader · GitHub
使用 socket 进行进程间通信以及同步问题
XiaoMi/LuckyMoneyTool · GitHub 使用 AccessibilityService 实现微信抢红包
有赞再加。。
请查阅「分布式计算」相关资料,至于能不能组织成超级计算机那倒要看你单部机器的计算能力有多大,以及机器总量。真实情况是,如果要达到目标计算能力,通常以提高单机计算能力为主,提高到性价比顶端时(再提高成本太高),再考虑组多台机子部署分布式计算网络。
Github 上有比较方便完善的解决方案:
想简单点的话也可以用 addJavascriptInterface() 为 WebView 提供 JS 接口,或者用
webView.loadUrl("javascript:your js code");
来调用网页内的 JS 接口
DOS 时期 BASIC 语言的启蒙。老爸有几本这样的书 =_=
Buck 的侵入性太强了,从 Gradle 切换过去的成本挺高的,现在 Android Studio 2.0 Preview 版已经出了,支持 Instant Run Feature!!!麻麻再也不用担心我的编译速度了。

文中作者脑洞蛮大的~ 不过这样做,作为 Presenter 的 Activity 对应的 View 无法复用,而且单个 Presenter 只能对应单个 View,限制比较大。
其实在任何开发中,很难实现某种纯的设计模式,通常是变种比较多。举个例子,在 MVP 模式中,其实可以将发送 Intent 启动另外一个 Activity 这种比较常见的操作定义为 View 层的操作。关键在于你要去平衡不同层之间的压力。
个人建议还是把 Activity 定义为 View 层会好些,界面逻辑这种东西本身复用的概率就比较低,直接在 Activity 中写就对了,而控制逻辑这种可复用的东西更应该抽象成 Presenter。
可以看看我专栏的文章:
#android# MVP 的尝试 - 『Android 还可以这样开发』 - 知乎专栏
当然,这只是我的一己之见而已啦。
只要你是在路由上嗅探,所有网络请求都能被抓到,和你 http 请求是不是在 so 库中发起没任何关系。
Fiddler 只能抓 http/https 协议的包(Wireshark 可以抓所有网络流量),你要先确定你要抓的包是 http/https 包才能用 Fiddler 抓。
碎片化
以上足矣,更多看得是你的学习能力。1W 在北上广深很易拿到。
请使用 tailrec 关键字:
tailrec fun sum(n: Int, res: Int): Int {
if (n <= 0) {
return res
} else {
return sum(n-1,res+n)
}
}
fun main(args: Array<String>) {
println(sum(5000000,0))
}
执行结果:

关于为什么需要显式修饰才进行尾递归优化(来自:
):

这样子来修改 View 的属性
textView.text = "修改 textView 的内容"
这样子来处理事件
override fun onTouch(v: View, event: MotionEvent): Boolean {
when (event.action) {
MotionEvent.ACTION_DOWN -> showToast("ACTION_DOWN ")
MotionEvent.ACTION_MOVE -> showToast("ACTION_MOVE ")
}
return true
}
这样子来使用 intent
val intent = intentFor<OtherActivity>(
"model" to Model(5, 0),
"str" to "xxx"
)
intent.singleTop()
startActivity(intent)
仅仅几行代码就定义了一个拥有单个 Fragment 的 Activity
public class MainActivity : SingleFragmentActivity() {
override val fragmentClass = TestFragment::class.java
override val fragmentBundle = {
null
}
}
这样子来储存本地数据(持久化)
Storage["test"] = Model(5, 1)
还有很多更多其他优雅的用法!!!请看:『Android 还可以这样开发』
安利完毕,别打我~
编码是一门艺术,无论是作家还是开发者,都追求优雅的作品。而优雅的代码对于开发者来说就是艺术品,它的「优雅」体现在「表现上的优雅」以及「设计上的优雅」。
kotlin 能很大程度上帮助我们实现「表现上的优雅」,它促进了语法上的极简,用先进的糖来取代 Java 臃肿的语法,使得简短的代码拥有更强的表达能力。当然「表现上的优雅」也包括代码风格上的统一,要保持良好的代码风格十分考验开发者的基本功。
而「设计上的优雅」需要考验开发者更高层次的功力,它指的是 代码组织上的优雅,需要开发者拥有大量的编码经验,以及很强的逻辑思维。早在 上个世纪七十年代 ,为了解决组织与复用代码的问题,就有开发者提出「设计模式」的概念。
这包括了早些时期的 MVC,以及现在比较流行的 MVP,MVVM 模式,它们通常指的是 GUI 领域的设计模式。它们描述了在 GUI 编程中组织与复用代码的一类方法。它们面对开发者而非机器,消耗或多或少的性能,来换得更好的可阅读性、可维护性以及可复用性。而我们今天要研究的是 MVP 设计模式。
在 Android 传统开发中,很多时候在 Activity(或 Fragment)下会产生数千行代码。按照传统的 MVC 设计模式,Activity 应该定义为 Controller的角色,它负责接收多个不同 View 的事件,并根据不同事件调用相应 Model 接口进行数据操作。
但实际上,纯的 MVC 模式在 Android 开发中并不存在,Activity 除了担任 Controller 之外还要负责一部分 View 的角色。归根究底是因为 Android 开发中被定义为 View 层的界面描述文件(layout,style 等 xml)能力十分有限,无法通过它完成所有对 View 的操作,导致很多界面操作必须 Activity 下实现(例如界面更新,复杂动画的实现等)。
Activity 中业务逻辑与界面操作耦合在一起,导致了当项目代码达到一定体量的时候,维护和升级代码变成了一件十分耗时和困难的事情。我们需要重新寻求 Android 开发中能更好组织、分层代码的设计模式,而 MVP 模式是种不错的选择。
MVP 设计模式使用 Presenter 充当中间人,负责原先 Controller 的角色,但是它完全隔离了 View 和 Model,Model 只能通过 Presenter 来更新界面(或者说通知界面更新)。
我们在 base_framework 中使用 MVP 模式来尝试设计代码,代码的层次结构如下图:

它包含的层次:
传统的 MVP 模式是单个 View 对应单个 Presenter。但是我们当将 Activity 定义为 View 之后,如果我们将原先 Activity 中所有控制逻辑仅迁移到单个 Presenter 上,会导致 Presenter 复用性低。所以我更倾向于根据逻辑拆分成不同的 Presenter,单个 Activity 对应多个 Presenter,而且每个 Presenter 可复用(n 对 n 关系)。
下面我们来实现个 Presenter 试试,它将负责从服务器获取天气信息,并通过接口通知 Activity 进行界面更新:
class WeatherPresenter(val itf: WeatherPresenter.ViewInterface) {
interface ViewInterface {
fun setWeather(weather: Weather)
}
fun fetchWeather() {
REST.api.getWeather("101010100").onUI().subscribe({
itf.setWeather(it)
})
}
}
于是,我们就可以在 Activity 中像下面这样引用 WeatherPresenter:
public class MainActivity : SingleFragmentActivity(), WeatherPresenter.ViewInterface {
// ...
val weatherPresenter = WeatherPresenter(this)
override fun afterCreate() {
weatherPresenter.fetchWeather()
}
override fun setWeather(weather: Weather) {
toolbar.title = weather.str
}
// ...
}
要注意的是,比较好的设计是:Presenter 通过接口来通知 Activity 进行 View 的更新,而不是直接操作 View,否则会造成 Presenter 和特定 View 的耦合。
使用 MVP 模式为代码进行分层,有助于我们清晰地进行代码组织,方便以后的维护:
话说回来,Android 前些时间发布的 Data Binding 库 不就为了提高 xml 在 View 层的控制能力么,不过,那已经算是 MVVM 设计模式了。
呃,只是漂亮的人不小心长胖了而已。
早期一些 DOS 软件、游戏都是屏幕独占的。




但是从当时一些软体的 UI 就能看出,已经使用矩形来分割功能区。主要原因是:

后期的一些 GUI OS(Windows,Mac,Linux),继承了使用矩形作为窗体的习惯,而且提供了绘制窗体的 GUI API,让平台下的应用也能创建风格一致的窗体。
当然 GUI OS 更重要的是创造了多任务的概念:在 OS 中不再只能运行单任务,多个任务(应用)可以并行处理。也就形成了现在多窗体的 GUI 模式。

同意
@vczh
的回答,在屏幕形状还是矩形的情况下,我觉得目前的 GUI 模式应该就是最终态了。
对于上一期文章末尾讲的 companion 还遗留了一些需要解释的地方。
KotlinClass.doSomething()
KotlinClass.Companion.doSomething()
另外,上期文章末尾在对 companion做解释时,提到了 named object,下面粗略提一下。
例如,我们可以在 Model 类内定义一个实名 object 对象 ModelList,并在每次新建 Model 的时候,将实例加入到 ModelList 中的 list 中。
data class Model(var test1: Int, var test2: Int): Parcelable {
constructor(source: Parcel): this(source.readInt(), source.readInt()) {
ModelList.list.add(this)
}
// ...
object ModelList {
val list = arrayListOf<Model>()
}
}
这样我们就维护了一个 全局的 ModelList 单例。当然,named object 还有其他用处,这里暂且就不细说了。
很抱歉拖了很长一段时间的稿,最近工作较忙,空闲时间较少,故而一直未跟进该系列专栏(好吧,其实是懒)。
另,如果时间充足的话,笔者会考虑再开一个 『使用 python 开发 Web』 系列专栏,初步构想是讲解tornado 的一些初、中级知识。专栏也会涉猎到,但不限于 「爬虫、Web Front-end」 等领域。
当然一切只是空想,事实上有出入的话请别打我 ╮(╯_╰)╭ 笔者是个懒人。
这节将对 kotlin_android_base_framework (以下简称 base_framework) 中的 activity/helper 进行讲解。
base_framework 使用的一个包结构如下:
com.nekocode.baseframework
├─ data
│ ├─ net
│ └─ local
│
├─ presenter
│
├─ ui
│ ├─ activity
│ ├─ adapter
│ ├─ fragment
│ └─ view
│
├─ utils
│
├─ App.kt
└─ Config.kt
为了方便,并没有将 kotlin 源码文件提取到新的 kotlin source 文件夹中。目前暂时混合储存在 java source 文件夹中。
得益于 Java 的继承机制,在 base_framework 中,我们可以实现一个抽象的 BaseActivity 类,并在其中实现一些 Activity 通用的方法(例如实现「应用内 UI 风格统一」),这样我们在添加新 Activity 时,只需要继承 BaseActivity 就能获取统一的 features 和接口。
在 BaseActivity.kt 中已经实现的通用接口:
使用 sendMsg(),sendMsgDelayed() 以及 runDelayed() 来实现 Activity 中异步通知。而继承 BaseActivity 的子类都 必须实现抽象的 handler() 方法,来处理异步传来的消息,例如:
public class MainActivity : BaseActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
sendMsgDelayed(msg(MSG.SHOW_HELLO), 1000)
}
object MSG {
const val SHOW_HELLO = 0
}
override fun handler(msg: Message) {
when(msg.what) {
MSG.SHOW_HELLO -> showToast("hello")
}
}
}
这样,在 Activity 创建后,会延迟一秒再发送 SHOW_HELLO 消息给自己,这个在很多异步场景下十分实用。例如进行一次异步网络请求,或者其他异步耗时操作时,在操作完成后,可以使用 sendMsg() 通知 Activity 已完成操作。注意:handler() 中的消息处理是在 UI Thread 中完成的。
另外,上面的 showToast() 的用法,可以使用 kotlin 的 Extensions 语法糖来实现:
public fun Context.showToast(any: Any) {
when(any) {
is Int ->
Toast.makeText(this, any, Toast.LENGTH_SHORT).show()
is String ->
Toast.makeText(this, any, Toast.LENGTH_SHORT).show()
}
}
这里,我们为 Context 类拓展了 showToast 外部函数,在 showToast() 内可以通过 this 变量来访问「 showToast() 当前所在 Context 的实例」,于是就可以在所有 Context 类及其子类下,使用我们自定义的 showToast 语法糖:
class ContextA : Context() {
fun toast() {
// normal
Toast.makeText(ContextA.this, "hello", Toast.LENGTH_SHORT).show()
// used extensions
showToast("hello")
}
}
其他的一些关于 Extensions 语法糖的例子可以参考 Sugar.kt (会不断完善),这是 kotlin 中十分强大的 feature,通过为类实现 Extensions 方法,创建各种语法糖,极大地缩减了代码量。
而 Activity 间,可以使用 broadcast() 来广播消息。假如,我们实现了一个 LogoutActivity 用来处理用户的账户登出交互。在登出成功后,可以使用 broadcast() 广播一条 LOGOUT 消息给所有 Activity,通知 Activity 账户已经登出,以便进行相应操作。
public class LogoutActivity : BaseActivity() {
fun logoutSuccess() {
broadcast(msg(BaseActivity.MSG.LOGOUT))
}
override fun handler(msg: Message) {
}
}
回到 BaseActivity.kt 中,我们来看看核心 MyHandler 的具体实现:
abstract class BaseActivity : AppCompatActivity() {
companion object {
private val handlers = arrayListOf<MyHandler>()
class MyHandler : Handler {
private val mOuter: WeakReference<BaseActivity>
constructor(activity: BaseActivity) {
mOuter = WeakReference(activity)
}
override fun handleMessage(msg: Message) {
if(mOuter.get() == null) {
BaseActivity.deleteHandler(this)
return
} else {
// ...
mOuter.get().handler(msg)
}
}
}
}
}
这里,MyHandler 被定义为 MainActivity 的内部类,关于 kotlin 中内部类的详细说明可以看 这里 ,在 kotlin 中,默认不加任何修饰词的内部类,都相当于 Java 中的静态内部类,也就是该内部类不持有外部类的实例。而添加了 inner 修饰词的内部类,会持有外部类的实例,可以通过BaseActivity.this 来访问外部类的实例。
我们在 companion object 中维护了一个静态全局 MyHandler 列表,在 Activity 执行 onCreate() 和 finish() 时分别入列和出列自己的 handler。这样我们就获得了一个动态储存所有运行中 Activity 的 Handler 列表。
当然,维护这个列表是为了实现 Activity 间 boradcast 功能。MyHandler 更详细的逻辑实现请自行看完整代码。
下面,我们来看看 runDelayed() 的具体实现:
public fun runDelayed(runnable: ()->Unit, delayMillis: Int) {
val msg = Message()
msg.what = -101
msg.arg1 = -102
msg.arg2 = -103
msg.obj = runnable
handler.sendMessageDelayed(msg, delayMillis.toLong())
}
这是一个 高阶函数 ,它把 runnable()匿名函数当做参数传入。注意,runnable 的类型定义为 ()->Unit。这个类型表示为:传参为空,返回为 Unit (空返回) 的匿名函数。
这样,我们就可以在 runDelayed() 中用使用 Lambda 表达式 :
runDelayed({ showToast("hello") }, 1000)
相信有不少朋友使用过 gradle-retrolambda 插件,但这是一种侵入式的 lambda 实现模拟。相对来说,kotlin 的原生 lambda 支持显得更为彻底,用起来也更加爽快,要知道 「在 kotlin 中,函数和其他值类型一样是一等公民」。

而 kotlin-android-extensions 已经默认为我们将大部分以前使用匿名类传参的各种系统接口,添加上 lambda 的支持,Cool!(。・`ω´・)
另外,在这里解释一下,我们利用 android.os.Message 中的三个参数来标志这是个带 runnable 的消息,在 MyHandler 处理消息时,通过三个参数标志来判断是否是个带 runnable 的消息,如果是的话,就执行该 runnable 函数:
if (msg.what == -101 && msg.arg1 == -102 && msg.arg2 == -103) {
val runnable = msg.obj as ()->Unit
runnable.invoke()
return
}
这是一个含有单个 Toolbar 和 Fragment 的 Activity 抽象类。在很多场景下,我们仅需要含有单个 Fragment 的 Activity,这时候就可以继承 SingleFragmentActivity:
public class MainActivity : SingleFragmentActivity() {
override val fragmentClass = TestFragment::class.java
override val fragmentBundle = {
null
}
override fun afterCreate() {
toolbar.title = "TestActivity"
}
override fun handler(msg: Message) {
}
}
是的,仅仅需要这几行代码就可以创建一个用 TestFragment 填充的 Activity。
我们来看看布局的具体实现:
relativeLayout {
include<Toolbar>(R.layout.toolbar) {
id = id_toolbar
}.lparams(width = matchParent, height = dip(50))
frameLayout {
id = id_fragment_content
}.lparams(width = matchParent, height = matchParent) {
below(id_toolbar)
}
}
我们使用了 anko 库来用 DSL 描述我们 SingleFragmentActivity 的 UI 布局,关于 anko 更详细介绍请查阅 该处 。
我们在 SingleFragmentActivity 中定义了两个抽象变量 fragmentClass,fragmentBundle(在 kotlin 中,支持在抽象类中定义抽象变量)。这样,我们在子类 override 这两个变量,就可以指定使用哪个 Fragment 来填充 Activity 了。
另外需要说明的两个地方是:
感觉这篇废话有些多了(kotlin 以外的东西讲得有些多),以后会多抽精华的地方来讲。心情好的话,也会讲一下 Android 上的一些东西。但是大家都知道的东西,就不多讲了。
顺便解释下,标题乱起的 =_=



首先, Visual Studio 先用各种领先 IDE 技术吸引大批 Android 开发者。然后,,就可以鼓吹开发者,以低成本将 Android 应用迁移到 Windows Phone 系统上啦。
navie

「创业无门槛,成功有门槛」。这个行业对普通人来说存在严重的「幸存者偏差」现象,大家看到的都是创业成功的媒体报道,实则大多创业团队都是在大潮中无声地死去。
『天使融资看团队,A 轮看项目,IPO 看数据』。然而实际上大多创业团队水平低下,产品粗制滥造,甚至衍生了 to VC 这种扭曲的创业模式。这样的团队能拿到首笔风投的已经不多,更别提什么 A 轮以后了。
利益相关:应届毕业生,创业公司从业人员。
洗牌算法 + 固定随机种子
大多数 3D 游戏中的技能特效都是使用「粒子系统」渲染的。
特效设计师通常对 粒子形状、颜色、数量、运动轨迹这些可编程,可量化的信息比较敏感,通过不断调整粒子渲染的效果,然后多个粒子运动效果整合在一起就形成了单个技能特效。
整个设计流程的话,大概是:特效设计师用 AE,或者粒子模拟器 设计出效果,然后工程师再通过粒子系统模拟出最终效果
题主可以尝试下:
Cocos2dx 在线粒子编辑系统:http://www.effecthub.com/particle2dx

Hybrid?效率已经不是问题?
自欺欺人,HTML 实现一个 Android 抽屉就卡出翔来。
HTML5 的优势在于排版,要做出相同效果的 Native 界面排版成本太大,所以内容展示页可以考虑使用 Hybrid 开发。逻辑关系复杂的页面还是老老实实用 Native 开发吧。
React Native?
还早着呢,Virtual DOM 对于需要复杂更新的页面一样显得乏力。这东西确实可以关注,热更新对于 Native APP 来说就是硬伤,React Native 不仅很好地解决了跨平台问题,还解决了热更新问题。
至于纯 HTML5 APP?
个人觉得不是很重度的 APP 都可以用 H5 来做,开发 Android 和 iOS 端的成本太高。现在不是还有 微信,公众号等平台么。
=== 11/6 更新 ===
有评论问到有 Github 账号的潜台词。
以下是我的回答,望能从中参考一二:
『我认识 github,我懂得在上面能找到高质量的开源代码,我会 git,我有代码能让你看』。不管你有没有共享代码,从你 star 的项目,面试官也能对你知个一二。
=============
有 Github,Blog,Stackoverflow,甚至知乎等账号的都有加分。我司很多情况下筛选的标准就是先看有没有 Github 账户,没的话就看项目经验,项目经验一般的就直接筛掉了。
本系列文章将通过解剖 kotlin_android_base_framework 项目,对其中的一些代码进行展开讲解,来挖掘 kotlin 在现实应用中的一些敏捷优雅之处。
本系列文章内容的侧重点是 「 kotlin 在 Android 开发中的实际应用」,通过现实代码来对 kotlin 的一些琐碎知识进行展开。所以作者建议读者,在阅读此系列文章之前先掌握 kotlin 的一些基础知识。
对于「如何在 Android Studio 中加入 kotlin 支持」,以及 kotlin 的一些基础语法,本系列文章不进行系统地讲解,读者可以参考下面两份文档。
在编码界当中,对于绝大部分 Java 公民来讲,要说服他们花学习成本在一门新的语言上并不容易,要推动他们将 kotlin 用在生产环境中更加不容易。
所以在文章开头,请允许我先对该次专栏的主角 kotlin 进行一番介绍,藉此宣扬下「使用 kotlin 代替 Java 进行编码」的想法~
下面,我将列举 kotlin 的语法上的一些先进思想。至于 kotlin 语言本身的一些优势,请参考上一篇文章 #前言# ,这里只谈谈 kotlin 的语法。
kotlin 里的变量定义有两种,val 和 var。其中 val 等同 Java 中 final 修饰的变量(只读)。kotlin 的变量定义支持 赋值时类型推断,且 所有变量默认被修饰为「不可为 null」,必须显式在类型后添加 ? 修饰符才可赋值为 null。
// Java
String strJava = "test"
// Kotlin
val strKot = "test"
var strNullable: String? = null
初次使用 kotlin 的用户可能会不习惯,在 Java 中,大多情况下变量都被定义为 nullable,这样可以通过对其赋值 null ,来表示该变量尚未初始化,或者该变量无数据。
但是这样要付出的代价往往是沉重的,默认类型为 nullable,导致了各种空类型安全问题。Java 代码中很多对外不透明的实现,你根本不知道返回值是否有可能为空,导致很多地方需要繁琐的非空检测,否则很容易触发 runtime error。
而 kotlin 明确地规定了所有类型默认为非空,这样的好处在于「从习惯上解决了空类型安全担忧」,无需频繁地担心变量是否为 null。但相应带来的一些成本就是,在变量初始化(赋值)阶段可能需要多做些功夫。
例如我在写 App.kt 中使用的巧妙的用法 (这里 companion object 代码块内的变量可以看作 Java 中的静态变量,关于 companion object 的介绍在下文会有提到) :
public class App : Application() {
override fun onCreate() {
super.onCreate()
instanceTmp = this
}
companion object {
private var instanceTmp: App? = null
public val instance: App by lazy {
instanceTmp!!
}
}
}
这里通过 lazy delegate 来对 instane 进行懒赋值(直到首次调用再进行赋值),这样,只要保证第一次对 instance 进行访问时 APP 已经实例化,那就可以保证 instance 恒不为空(大多情况下,你在 Android 开发中对Application 的实例进行访问时,该 Application 通常就已经被实例化了)。
形如上面的奇技淫巧还有很多,日后再详细展开说。而对于 nullable 的变量,可以使用 ?. 运算符检验是否为 null,如果为 null 则不运行运算符后的操作。
或者使用 !.运算符来强制访问 nullable 变量的子属性或方法,如果该变量为 null 的话,就在运行时抛出错误:
var strNullable: String? = null
strNullable?.trim()
strNullable!.trim()
总结下。感觉 kotlin 的思想就是,尽量习惯性地将变量设计为 不可为空,这样在后面对该变量的运算中会减少很多问题。
不用再通过匿名对象传递方法,直接支持形如下面的写法:
view.setOnClickListener({
// do something...
})
关于 kotlin 中的匿名类和 lambdas 的具体应用,会在以后的篇幅介绍。
例如下面对于 View 类的拓展:
public val View.ctx: Context
get() = getContext()
进行以上定义后,就可以在所有 View 及其子类内直接访问 ctx 属性来取代调用 getContext(),多么美妙的事情!很多 kotlin 的外部库都依赖这个特性,来生成一些减少编码量的语法糖。
例如 kotlin 默认为已定义的类属性生成 getter,setter,并支持形如下面的语法糖:
// Java
textView.setText("test")
showToast(textView.getText().toString())
// Kotlin
textView.text = "test"
showToast(textView.text.toString())
安利了 kotlin 的一大堆神油后,我们还是回到本系列的核心内容吧。本系列主要对 kotlin 在 Android 开发中的一些敏捷实现进行讲解。上文讲了一些 kotlin 语法上的强大之处,但是难以在这么短的篇幅内将 kotlin 的语法全部覆盖完。
所以作者还是希望读者先详细读完 kotlin 的官方文档,再结合本系列文章去理解 kotlin,以及去思考如何在 Android 开发里使用 kotlin 提高生产效率。
下面本系列正文将从 kotlin_android_base_framework 中第一个 kotlin 类进行展开讲解。
正文终于开始啦~本次内容将围绕 Model.kt 的代码,讲解 kotlin 中的 data class 以及它在 Android 开发中的一些应用。
我们可以像下面这样定义一个简单的 data 类:
data class Model(var test1: Int, var test2: Int)
data 关键字提供以下的一些 features:
按上面第三点的解释,可以理解为 test1 按照属性定义的顺序与component1() 函数对应,test2 则对应 component2()。
为什么需要 componentN() 函数呢?可以参考 Multi-Declarations 这节,主要是为了实现 多重赋值,解锁下列各种便利的写法:
val (test1, test2) = model
// 内部实现为:
// test1 = model.component1()
// test2 = model.component2()
var list = arrayListOf<Model>()
for((t1, t2) in list ) { ... }
另外,kotlin 中提供了 Pair 类来处理双元对数据,例如跳转到其他Activity 时可以这样:
val intent = intentFor<OtherActivity>(
"data" to Model(5, 0),
"data2" to "xxx"
)
intent.singleTop()
startActivity(intent)
其中 “data2” to Model(5, 0) 的等价实现其实就是:
Pair<String, Any>("data2", Model(5, 0))
data class 提供的 copy() 函数是 深度复制,其内部实现如下:
fun copy(test1: Int = this.test1, test2: Int = this.test2) = Model(test1, test2)
于是乎能够支持下面这种优雅的用法~:
val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)
在 Android 中,Activity 之间需要传递数据通常需要对数据进行序列化,data class 就必须继承 Parcelable 或 Serializable 接口。结合我们上面的一些 points,可以对 Model 类进行如下的改造:
data class Model(var test1: Int, var test2: Int): Parcelable {
constructor(source: Parcel): this(source.readInt(), source.readInt())
override fun describeContents(): Int {
return 0
}
override fun writeToParcel(dest: Parcel?, flags: Int) {
dest?.writeInt(this.test1)
dest?.writeInt(this.test2)
}
companion object {
@JvmField final val CREATOR: Parcelable.Creator<Model> = object : Parcelable.Creator<Model> {
override fun createFromParcel(source: Parcel): Model{
return Model(source)
}
override fun newArray(size: Int): Array<Model?> {
return arrayOfNulls(size)
}
}
}
}
在上面的一坨代码中(大雾),我们先看看 data class 的构造函数。在 kotlin 的 官方文档 constructor 小结 中指定了,写在类定义头部(类名后面)的为首要构造函数 ,也就是下面这段已经构成了 data class 的类定义及 primary constructor:
data class Model(var test1: Int, var test2: Int) { ... }
而其内部显式定义的的 constructor(source: Parcel) 则为副构造函数,其传入值类型为 Parcel,返回值为 使用主构造函数构造后的 class:
this(source.readInt(), source.readInt())
翻译自 kotlin doc
不像 Java 或者 C#,在 Kotlin 中,Class 没有静态方法。在大多数情况下,推荐用 package-level 的函数来代替静态方法。
如果你需要写一个不需要实例化 Class 就能访问 Class 内部的函数(例如一个工厂函数),你可以 把它声明成 Class 内的一个实名 Object 。
另外,如果你在 Class 内声明了一个 companion object,在该对象内的所有成员都将相当于使用了 Java/C# 语法中的 static 修饰符,在外部只能通过类名来对这些属性或者函数进行访问。
而至于 @JvmField 的作用可以参考 Java Interop - Fields
至此,我们已经可以在 Android 中使用 kotlin 很轻易地定义一些我们需要的数据类,这是一次很不错的收获。下一章节,我们将提高下难度,从我们的 activity helper 讲起。
让我想起大学时参加学校游戏制作竞赛的一件趣事:
当时我用 C++ 直接配合 DirectX 接口写了个弹幕游戏 nekocode/BattleBeats
里面的各种 3D 变换、Shader 效果、数学运算都花了我不少时间,结果却输给了一个拿 RPG Maker 做出来的游戏(而且剧情完成度很低,更像个 demo),最终我的游戏只拿了个二等奖,泪目,。
回到正题:
十五六岁能用游戏引擎制作游戏并不是一件特别难的事情,现在很多少儿编程软件甚至能让你通过 GUI/WYSIWYG 的方式来编程,不用写任何代码,拖动下积木就能写出简单的游戏了。但如果是十五六岁就能直接用图形接口写出一个完整的游戏甚至是游戏引擎倒是有一定难度。
当然这个年纪可以用游戏引擎来做游戏至少说明了他有一定的天赋并且有很强的动手能力,是值得称赞的。
抽空把这个专栏给开张了,这是一个讲述「使用 Kotlin 进行 Android 编码」的专栏,致力于传播让 Kotlin 成为 Android 开发世界的 Swift 的(非?)异端思想。专栏作者将边学边沉淀,分享一些在使用 Kotlin 进行开发的一些心得。
另外,作者在 Github 上长期维护了一个使用 Kotlin 进行 Android 开发的实践框架 nekocode/kotlin_android_base_framework · GitHub ,它包括了一些先进的 Lib,并且尝试使用 MVP 设计模式来组织代码。大多数专栏上的代码都将抽选自该仓库,在此也希望有能力的人能够一起维护代码~ ✪ω✪
至于为什么要开专栏写这系列文章呢。作者使用 Java 进行 Android 开发已经大概有两个年头了,Java 作为一门类 C 风格传统语言难免会有很多历史包袱,相对于很多新兴的语言总感觉有些旧而沉重了,很多时候写起代码来,让人觉得很这门语言真的沉闷(特别是最近写了几个月 Python 再切回 Java)。毕竟 Java 在语法上没什么可把玩的 feature,能玩的也就那几个设计模式了。
然而,很庆幸的是得力于 Java 虚拟机大法的设计,最近一段时间衍生了一大堆现代化的 JVM 语言,而且一部分还兼容 Dalvik/ART 。它们大量纳入一些先进的语法,并将代码最终编译成字节码运行在 JVM 上(题外话:想想,SASS,CoffeeScript 的原理也相似),这同时也让开发者在 Android 开发上有了选择其他语言的可能性(Sky/Dart,Go 大法再见)。
目前比较火的 JVM 语言有 Scala,Groovy,Clojure 等,而作者为什么选择 Kotlin 呢,在作者的一些知乎回答中有提及,主要有以下两个点:
以上两点保证了 Android 开发者可以无缝从旧项目切换到 Java + Kotlin 甚至完全使用 Kotlin 的模式下。
而讲到为什么要加入 Kotlin 大军的话,当然是因为 Kotlin 语言各种先进的 Feature(详见 如何评价 Kotlin 语言? - Java )。简洁的语法,安全检测空指针,更好的 Lambda 支持,更好的函数(一级公民),泛型。更多关于 Kotlin 的介绍请看官方文档:Reference 。
本系列专栏中也会列举 Kotlin 语法上一些先进的 Feature,以及在 Android 开发中的一些应用,敬请关注~
http://drops.wooyun.org/papers/10061
百度这厮也是够狠毒的了,本地开个 http 服务器,随便个网页发个 ajax 请求就能下载打开百度各种全家桶。
不问是不是,就问为什么。
绝大部分长得丑的人都不自恋,只是长得丑而又自恋的人显得格外突出而已。
题主试试这个: droidwolf/NativeSubprocess · GitHub
创建 linux 子进程的 so 库,当初用在 service 免杀上,经测试,在大部分机子上有用。
安全软件卸载后调出浏览器苦苦哀求"主人,为什么要抛弃我…“页面是怎么做到的? service 经常莫名挂了肿么办?用 NativeSubprocess 一切都很简单。
NativeSubprocess 是一个可以让你在 android 程序中创建 linux 子进程并执行你的 java 代码的 so 库。由于市面上典型的内存清理工具值清理 apk 包关联的进程,而不会处理 linux 原生进程,所以 NativeSubprocess 可以做什么您懂滴!
其实是「在国内 APP 越来越难做」,个人认为有以下几个原因:
占大头的 APP 都在往平台级发展,超级 APP 功能越来越发散,逐渐侵蚀其他领域的市场。
微信,UC 浏览器此类产品开放 APP 内子产品开发平台,令 APP 开发者左右为难。就拿微信来说,很多时候,开发一款 APP 的产出投入比远远不及做公众号高,于是很大部分开发者会更倾向于开发公众号(微信用户基数大,应用内传播方便,公众号开发成本低)。
国内产品乃至创投圈风气不好,都想打擦边球,吃快餐,抄抄抄,塞塞赛,概念满天飞。『站在中国风口上的猪,还真的能飞得起来』。
在国内,知识产权就是个屁。没有绝对的技术壁垒和积累,就等着随时被巨头啃掉,所以大多数创业团队都只能跑去做巨头无法触及的领域,乃至于现在提「社交」色变。国外都是收购,并购,国内就是有好的 idea 大家一起抄,抄着抄着巨头不乐意了,也抄了起来,很多时候就变成了一场「能否在巨头之前积累足够资本」的博弈。。最蛋疼的是 idea 很多时候还是来自国外。
中国用户对应用忠诚度很低(国内产品的体验差,玩法单一等原因)
相对于美国国外的用户,美国用户对应用的忠诚度更高。在美国,被用户多次打开的应用占比今年上升了1%,至42%。这可能是由于,大量广告吸引用户重新打开已安装的应用。在美国,只被打开过一次的应用占比为19%,与去年持平。然而在美国国外,尤其是中国,应用只被打开一次的概率很高。在中国,有37%的应用只被打开过一次,远高于2014年时的26%。
说到底,是因为

按现在科技发展状况,未来人已经产生生理,文化变异。回到现在应该是要消灭当代人,占领当前资源充沛的世界。
技术上找原因的话大概很关键的一点是: 工程师还原能力低。。
其他可能是:
==== 以下是对设计上找原因的一些看法 ====


个人认为最重要的原因在于:
其中最重要的应该是 设计统一感!检验的标准就是检查 APP 是否有 统一的调色板,统一风格的 icon 库,统一的 dimen 表。以及 APP 内是否有没有令人感觉「异类」的元素。通常能做到设计感统一就不会显得太过粗糙。
而「好的 UI 设计」必然是需要设计师和工程师共同努力的(一个 具有设计感的前端工程师和 一个有基础代码能力的设计师 十分重要)
readme 上对于为什么要使用 DSL 代替 XML 已经讲得非常清楚了(
https://github.com/JetBrains/anko#why-dsl
)
使用 XML 来描述 UI 的缺点:
- It is not typesafe
- It is not null-safe
- It forces you to write almost the same code for every layout you make
- XML is parsed on the device wasting CPU time and battery
- Most of all, it allows no code reuse.
可读性:DSL >= XML > normal code
执行效率:normal code >= DSL > XML
DSL 本身就是为配置而生,既然语言内部支持配置,为何要还要使用外部配置文件(XML)呢?
当然,要和其他应用交互时,也只能用外部文件了~
nekocode/kotlin_android_base_framework · GitHub 正打算这周内 update 到 1.0 版。里面有很多 kotlin 编写 android 应用的最佳实践。
占坑,有空再填。
转行做投资人,实现财务自由,找个高层次圈子内的老婆,过美滋滋的生活。
投入大量资本去做「自己想做的产品」,建立下一个能 IPO 的企业。
一觉梦醒。。。继续搬砖去
不显示 UAC 窗口的话(bypass UAC)必须使用 hack 的方法:
nishang/Invoke-PsUACme.ps1· GitHub
或者参考下我写的渗透脚本(bat & ps1):
nekocode/win_penetration · GitHub
可以绕过 UAC 获取管理员权限。但是里面有很多其他危险操作,不要乱试。
==== 想知道 bypass 原理的话可以评论下,我再补上 ====
PHP 是世界上最好的语言。
曾经做过面试官的告诉你,你虽然讲了一大堆,但是让人觉得全都是懂一点而已,反而会显得 low。建议先纵向深度学习,然后再横向发展会好很多。
『做过平面设计,写过书籍,改过 bbs』 这些就别拿出来了,因为这些在面试官眼里就觉得毫无价值,有滥竽充数的怀疑,在没有把一项技能学到中上水平之前,私认为都不应该将其作为自身技术筹码,甚至不值一提。
技能广度很重要,但是,在尚未精通任何一个领域前,你的技能广度只能说明你是一个没有耐力,或者没有能力深入任何一个领域的人。
මම ඔබට කියන්න අවශ්ය, මම ඔයාට ආදරෙයි
试试复制第一行的,android 系统下无法正常显示的。

至于为什么无法显示是因为系统没装这种语种的字体文件,无法得知该类字体该如何渲染。打个比方,如果某美国人手机系统的字体库里只安装了英文字体的话,那么他们看中文也会无法正常显示。
Processing!OpenProcessing
或者 python 也不错~
有什么好好奇的,internet 并没有你想象那么安全。hacker 只要掌握几个未公布的 system 或者常用 app 的 0day exploit 就可以轻松随便入侵你的设备。
可以参考
例如上面这个最近公布的 android stagefright exploit,只需 hacker 发一条携有特殊格式视频的 mms 给你,就应该可以获取你手机的控制权。
针对上述新闻的描述情况,假设如果受害者是同时更换手机和手机号,却依然被感染的话。有下面几种可能:
顺便说一下。在黑市上,一个高危级别的 0day exploit 可以卖出几十万的价格。其实,对于大多数没有安全意识的人来说,一个有能力的 hacker 想 hack 进你的生活实在是太简单的。
@叛逆者 大神已经回答了。全场景(全屏)特效就应该使用处于渲染管线后期的 post process 来实现。(可搜索关键词 render to texture,post process)
可以,而且没有 native app 逆向那么麻烦。native app 的指令都是编译成机器码的,web app 在浏览器端执行的大都是脚本,本身就少了反编译的成本。而且在 浏览器开发工具的帮助下,什么前段加密手段对于资深开发者来说都是个摆设而已。
搞起破坏来,powershell 可方便多了,bypass 各种杀软做高危操作毫无压力。正常用户很少会用到 ps1脚本,默认不可运行是出于安全考虑。
节选并重新排版自:探寻C++最快的读取文件的方案
为确保准确性,我又换到Windows平台上测试了一下。结果如下表:
从上面可以看出几个问题
- Linux 平台上运行程序普遍比 Windows 上快。
- Windows 下 VC 编译的程序一般运行比 MINGW(MINimal Gcc for Windows)快。
- VC 对 cin 取消同步与否不敏感,前后效率相同。反过来 MINGW 则非常敏感,前后效率相差8倍
- read 本是 linux 系统函数,MINGW 可能采用了某种模拟方式,read 比 fread 更慢。
- Pascal 程序运行速度实在令人不敢恭维。
好像黑了不少东西 :) 个人意见是 大文件的话使用 fread,不考虑效率以及内存占用的话可以考虑 fstream。example:高效地读取&解析文件(fread)
Github 上有关注的的话:
非 Github,一些站点:
个人认为还是有蛮大机会的,主要有两个点:
以上两个点保证了 Android 开发者可以无缝从旧项目切换到 java + kotlin 甚至完全使用 kotlin 的模式下。而能够诱导用户加入 kotlin 大军的话,当然是 kotlin 各种语言 feature(详见
)安全检测空指针,更好的 Lambda 支持,更好的函数(一级公民),泛型。
更多关于 kotlin 的介绍请看官方文档:
个人已经使用 kotlin 开发新项目有几个月了,开发中代码量锐减了大概 50%,开发效率提高了 30% 以上。唯一弊端是 kotlin 依然处于高速发展中,个人维护的一个项目在开发途中就经历了 kotlin 的两次大改动,语法变动较大。所以 生产环境请下慎用。
使用 kotlin 进行 Android 的基本框架:
Create infographics & online charts
什么?你想做一些漂亮的图表,但是找不到好的工具?别瞎忙活了,你要找的就是它!!(答主的简历图表就是用它做的!)


___ ___ ___ ___
/\__\ /\ \ /\__\ /\ \
/:| _|_ /::\ \ /:/ _/_ /::\ \
/::|/\__\ /::\:\__\ /::-"\__\ /:/\:\__\
\/|::/ / \:\:\/ / \;:;-",-" \:\/:/ /
|:/ / \:\/ / |:| | \::/ /
\/__/ \/__/ \|__| \/__/






===================
蹲着坑,以后还有再补上
曾经大学时期写的一个 AVG 引擎:

单个项目的话大概只有接近一万,但是衍生出的其他项目加起来估计就有好几万了,当时的感觉就是 书中看到的东西永远都不如真正实践一次来的实在而且写的是你感兴趣的东西的话,更容易带动你去思考。
顺便提一下,其实大多数对游戏感兴趣的人,在大学阶段都可以去尝试下写些简单的游戏,甚至是 Game Engine ,开发一个 GE 所需要学习的知识太多了,例如 数学知识,三维空间知识,渲染技术,算法,语法解析,GPU 编程 甚至 简单的平面设计等(参考:
游戏开发的编程算不算是 IT 行业中难度最大的? - 程序员
)
从游戏编程领域转到其他编程领域,很大程度上也会让你看事物的角度也发生改变,特别是转到前端开发上~ 你能理解大致知道程序 UI 是通过哪些步骤最终渲染到屏幕上的,对 Render 这个词也变得有特殊情感了
总而言之,你老师的话 大体上是没有错的,代码写得越多,你与机器就越亲近,越能理解如何通过语言与机器沟通。
生产环境下还是要慎用新技术(虽然我个人很喜欢将新技术用到生产中,但是前提是已经对新技术有较深掌握)。个人学习的话,新技术提供了编程界一些最新的思想,学习了的话不无好处。
flask + Jinjia2 + react,豆瓣的大神在这样搞
CSS Selector
请使用 Android Studio 和 Gradle 来组织开发你的项目,这是官方推荐的工具集(Android Studio 是谷歌基于 IntelliJ IDEA 开发的,可以勉强算得上是官方开发的 IDE,和 Eclipse 的官方只提供插件支持完全不是一个态度)。
另外现在 Github 上大多数 Android 项目也都是用 Android Studio 来开发维护的。个人是国内最早一批从 Eclipse 转到 Android Studio 的开发者,从 0.x 版本到现在 1.x,Android Studio 对于 Android 开发的效率提高和亲和度都是 Eclipse 所无法比拟的。
PS:顺便可以跟上时代的步伐,尝试下同家 JetBrains 发布的 kotlin 语言~
sh 脚本只是 bash 的一部分,学学 bash 的命令就行了,涉及复杂控制什么的还真不如用 py 来做。不过有些设备不支持 py 或 ruby,这种时刻也只能用 sh 来做了(原生亲和),很好的例子还有 bat 批处理。
学不学 python 只看你有否兴趣,是发自于自身学习欲望的,不应该和你的职业规划过度或者说过早挂钩,理论上 java 还有很多你可以深入学习的地方。正面回答题主问题的话:
称职的程序员至少掌握两门以上的语言(编译型语言 & 解析型语言),以题主情况而言,建议先继续深入学习 java,同时可尝试下 python,等认为 python 可以作为自己主要技术栈语言的时候再去考虑是否换职。
本人就是学习过 vb(6),c++,lua,java,python,kotlin 才确定目前主要技术栈的,工作还工作,兴趣还兴趣,学习还学习。
groovy 在国内推广得不怎么样,grails 也缺乏工业级产品验证。但我个人很是看好它。