【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code

文章目录

  • 前言
  • 1. 工具准备
    • 1.0 事先说明
    • 1.1 VSCode
    • 1.2 Fitten Code
    • 1.3 GitHub Copilot
  • 2. 使用测评
    • 2.1 需求理解
    • 2.2 上下文理解
  • 3. 总结
  • 推荐链接

开年尝鲜高质量国产AI编码助手——FittenCode

前言

2024年刚刚开局,清华大学 与 非十科技 就发布了全新的 VSCode AI 编码助手—— FittenCode。 感谢我的大佬同学小金推荐,让我及时收到咨询,第一时间体验FittenCode!

截止至本文发文日期,FittenCode 可在 VSCode 商城下载并免费试用!借此契机,我索性将我自己的Copilot拿出来,与FittenCode做一个使用体验对比。此文就当是用户使用测评了!

由于我本人只是渣渣 Java 开发,并不懂很多AI知识,目前工作与生活中对AI仅略懂皮毛,日常仅使用AI而并无细致研究,因此本文只讨论如何使用FittenCode及Copilot,并不深入探究其原理。

当然了,还得事先说明,由于个人非专业测评工程师,样本有限,测评结果仅代表个人观点,轻喷。建议读者将本文当作单纯的“Fitten Code的使用”参考文章。

工具

  • VSCode 1.84 以上
  • GitHub Copilot
  • 一个项目或一段代码

由于本人目前 是 Java 方向, 本文就用Java 演示啦。

测评维度

  • 同一需求场景下,对同一个需求注释生成的代码对比
  • 同一代码注释,对上下文的理解生成的代码对比

1. 工具准备

这一小节,介绍如何准备相关工具,包括:下载对应 VSCode 版本,FittenCode 插件下载,注册;Copilot 购买;

1.0 事先说明

我们在使用FittenCode前,由上文提到的小金大佬指导,需要事先了解FittenCode现阶段如下几点:

  • 目前仅支持 VSCode 插件
  • VSCode 版本需要在 1.84 以上
  • 目前免费试用,以后是否收费,要看开发商非十科技的战略

1.1 VSCode

首先我们下载 VSCode,并配置所需的基础环境:

下载安装及配置
下载地址:
VSCode下载地址
https://code.visualstudio.com/download

安装完成后,插件下载、程序运行测试参考文章:
腾讯云社区-VSCode配置JAVA环境参考文章

VSCode 所需Java测试插件
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第1张图片

【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第2张图片

这里我个人使用的是免安装解压版,除了要注意VsCode默认的插件安装位置是C:\用户\当前用户.vscode\extensions这一点外,其它基本是可插拔,开箱即用(手动狗头[doge]),不需要额外太多配置,除非有一些特别的需求要配置环境等。

1.2 Fitten Code

下载并注册FittenCode
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第3张图片

【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第4张图片

注册完马上可以使用!

1.3 GitHub Copilot

开通GirHub Copilot

  • CSDN-GitHubCopilot优秀参考文章

2. 使用测评

以下基于同一段代码,分别使用 FittenCode 与 GitHub Copilot,体验能力区别。

2.1 需求理解

代码准备
准备一个main方法。一个测试类,用于验证代码是否正确。

需求
以下是一个顺序表

package cn.sharry.structure.linearlist;

import cn.sharry.structure.util.GenericTypeChangeUtil;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * 顺序表的实现
 * @author Sharry
 * @since 2023/9/16
 */
public class SequenceTable<T> implements ISequenceTable<T> {

    /**
     * init length : 0
     */
    public final int INIT_LENGTH = 0;

    /**
     * hash code constant
     */
    public final int HASH_TIMES = 31;

    /**
     * array to store sequence data
     */
    private Object [] elements;

    /**
     * this sequence table's length
     */
    private int length;

    public SequenceTable(T[] elements) {
        this.elements = elements;
        this.length = elements.length;
    }

    public SequenceTable(int length) {
        this.elements = new Object[length];
        this.length = length;
    }

    public SequenceTable() {
        this.elements = new Object[INIT_LENGTH];
        this.length = INIT_LENGTH;
    }

    public SequenceTable(T[] elements, int length) {
        if(length < elements.length){
            throw new ArrayIndexOutOfBoundsException();
        }
        this.elements = elements;
        this.length = length;
    }

    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
        this.length = elements.length;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof SequenceTable)) {
            return false;
        }
        SequenceTable<?> that = (SequenceTable<?>) o;
        return getLength() == that.getLength() && Arrays.equals(getElements(), that.getElements());
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(getLength());
        result =HASH_TIMES * result + Arrays.hashCode(getElements());
        return result;
    }

    @Override
    public String toString() {
        return "SequenceTable{" +
                "elements=" + Arrays.toString(elements) +
                ", length=" + length +
                '}';
    }

    @Override
    public boolean isEmpty() {
        if (elements.length == 0){
            return this.getLength() == INIT_LENGTH || this.getElements() == null;
        }
        for (Object element : elements) {
            if (null != element) {
                return false;
            }
        }
        return true;
    }

    @Override
    public int size() {
        return getLength();
    }

    @Override
    public T get(int i) {
        if(i < INIT_LENGTH || i > length-1){
            throw new ArrayIndexOutOfBoundsException();
        }
        return GenericTypeChangeUtil.typeConversion(getElements()[i], getElements()[i].getClass());
    }

    @Override
    public boolean set(int i, T x) {
        if(isOutOfBounds(i)){
            throw new ArrayIndexOutOfBoundsException();
        }
        Object[] eArr = getElements();
        Object e = getElements()[i];
        if ( e == null || !e.equals(x)) {
            eArr[i] = x;
            setElements(eArr);
            return true;
        }
        return false;
    }

    @Override
    public int insert(int i, T x) {
        if(isOutOfBounds(i)){
            throw new ArrayIndexOutOfBoundsException();
        }
        Object[] resource = getElements();
        Object[] target = new Object[this.length+1];
        if(i == 0){
            System.arraycopy(resource,0,target,i+1,resource.length);
            target[i] = x;
        }else{
            System.arraycopy(resource,0,target,0,i);
            target[i] = x;
            System.arraycopy(resource,i,target,i+1,resource.length-i);
        }
        setElements(target);
        return i;
    }

    @Override
    public int insert(T x) {
       return insert(length-1,x);
    }

    @Override
    public T remove(int i) {
        if(isOutOfBounds(i)){
            throw new ArrayIndexOutOfBoundsException();
        }
        Object e = getElements()[i];
        Object[] eArr = getElements();
        eArr[i] = null;
        setElements(eArr);
        return GenericTypeChangeUtil.typeConversion(e,e.getClass());
    }

    @Override
    public int search(T key) {
        Object[] eArr = getElements();
        for (int i = 0 ; i < eArr.length ; i++){
            boolean ifNull = eArr[i] != null && eArr[i] == key;
            if(ifNull || Objects.equals(eArr[i], key)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(T key) {
        return search(key) != -1;
    }

    @Override
    public int insertDifferent(T x) {
        if(contains(x)){
            return -1;
        }
        insert(x);
        return length-1;
    }

    @Override
    public T remove(T key) {
        T element;
        if (!contains(key)) {
            return null;
        } else {
            element = GenericTypeChangeUtil.typeConversion(getElements()[search(key)],getElements()[search(key)].getClass());
            set(search(key), null);
        }
        return GenericTypeChangeUtil.typeConversion(element,element.getClass());
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean addAll(List<T> list) {
        if (list == null || list.size() == 0){
            return false;
        }
        Object[] source = getElements();
        Object [] tar = new Object[this.getLength() + list.size()];
        int tarLength = tar.length;
        if (this.length >= 0) {
            System.arraycopy(source, 0, tar, 0, this.length);
        }
        for(int i = this.length-1; i < tarLength; i++){
            tar[i] = list.get(tarLength-i);
        }
        SequenceTable<T> ns = new SequenceTable<T>((T[])tar,tarLength);
        setElements(ns.getElements());
        setLength(ns.length);
        return true;
    }

    private boolean isOutOfBounds(int i) {
        return i < INIT_LENGTH || i > length - 1;
    }
    
}
  • 对该顺序表进行代码优化,尽可能简洁

GitHub Copilot
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第5张图片

显然,稍微复杂的一些代码Copilot并不能理解其意思。这种情况,不如暂时关一下Copilot。

Fitten Code
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第6张图片

像模像样,对上述代码

@Override
    @SuppressWarnings("unchecked")
    public boolean addAll(List<T> list) {
        if (list == null || list.size() == 0){
            return false;
        }
        Object[] source = getElements();
        Object [] tar = new Object[this.getLength() + list.size()];
        int tarLength = tar.length;
        if (this.length >= 0) {
            System.arraycopy(source, 0, tar, 0, this.length);
        }
        for(int i = this.length-1; i < tarLength; i++){
            tar[i] = list.get(tarLength-i);
        }
        SequenceTable<T> ns = new SequenceTable<T>((T[])tar,tarLength);
        setElements(ns.getElements());
        setLength(ns.length);
        return true;
    }

这一段进行了重写,看起来比Copilot更靠谱些,甚至看起来确实优化了点代码。

因此,这一part,仅此需求的测试,Fitten Code 胜。

至于更多的测试,篇幅有限,请读者自行发掘啦。

2.2 上下文理解

测试需求

  • 在中间插入一段,该线性表参数进行希尔排序

GitHub Copilot
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第7张图片

Fitten Code
【国产之光】开年尝鲜——优秀的AI编码助手 Fitten Code_第8张图片

上图结果不相上下,其中Fitten Code生的甚至多了一些,略不符合题意,看起来是忘了上文的内容了。这一part 算是GitHub Copilot小优吧!

至于更多的测试,请读者自行发掘咯。

3. 总结

经过本次测试,我个人对 Fitten Code 插件 与 GitHub Copilot 的比较,体验结果:

Fitten Code 优缺点:
优点

  • 免费
  • 某些业务,理解比GitHub Copilot好一些
  • 更新,更年轻

缺点

  • 目前仅VSCode 1.84 以上版本能用。其它工具和平台里不能用,对于不常用VSCode开发的程序猿不友好。
  • 目前一天一个版本,几乎每天上号第一天就要点击更新,略显麻烦

GitHub Copilot 优缺点:
优点

  • 多个工具里均可使用
  • 重复性代码,生成能力很强,减少程序猿重复性工作
  • 有GitHub数据投喂,可获得非常多开源方案参考

缺点

  • 贵,学生包申请有条件限制
  • 有时略显笨拙,生成的不是咱想要的,还不如停掉

好啦,个人对这两个AI编码助手的体验测评大概就是这些啦,若您是VSCode忠实用户,恭喜您,有 GitHub Copilot 的平替方案啦,甚至说,对某些代码的理解更胜一筹。 当然,这里也忠心祝愿国产AI助手能更上一层楼,早日让国人用上性价比更高的国产AI助手

推荐链接

  • VS插件商城
  • 非十科技
  • VSCode下载地址
  • 腾讯云社区-VSCode配置JAVA环境参考文章
  • CSDN-GitHubCopilot优秀参考文章

你可能感兴趣的:(工具与中间件,人工智能)